wendkeep 0.64.0 → 0.66.0

package/packages/integrations/src/host-hooks.mjs

@@ -0,0 +1,80 @@
+// Host hook specifications shared by the installer and CLI. This catalog is
+// data-only and side-effect free so host adapters can import it cheaply.
+
+// The three Claude Code session hooks, expressed as `wendkeep hook <name>` so the
+// installed package is the single source of truth (update with `npm update wendkeep`,
+// no re-copying). Returned as a spec the merge logic folds into settings.json.
+export const SESSION_HOOKS = [
+  // Memory + active-change injection. Runs FIRST on SessionStart (order -10, folds before
+  // session-start) so the agent gets CORE + DIGEST + the active change + lessons as context.
+  // matcher 'startup|clear|compact' re-injects after a compaction/clear, not only cold startup.
+  // timeout 45 (was 15): measured ~4s warm via npx, but Windows startup contention (several npx
+  // cold-starts at once — a sibling MCP took 26s in a real log) blew 15s and silently dropped the
+  // memory injection for the whole session.
+  { event: 'SessionStart', matcher: 'startup|clear|compact', name: 'brain-inject', timeout: 45, order: -10, codex: true, statusMessage: 'wendkeep: injecting memory + active change' },
+  { event: 'SessionStart', matcher: 'startup', name: 'session-start', timeout: 30, codex: true, statusMessage: 'wendkeep: opening Obsidian session' },
+  { event: 'Stop', matcher: null, name: 'session-stop', timeout: 60, codex: true, statusMessage: 'wendkeep: writing session checkpoint' },
+  { event: 'UserPromptSubmit', matcher: null, name: 'session-ensure', timeout: 30, codex: true, statusMessage: 'wendkeep: ensuring active session' },
+  // Capture an interactive decision (AskUserQuestion) — options + the user's choice — into 04-Decisões.
+  // codex: AskUserQuestion is a Claude-only tool; there is nothing to match on.
+  { event: 'PostToolUse', matcher: 'AskUserQuestion', name: 'decision-capture', timeout: 15, statusMessage: 'wendkeep: recording decision' },
+  // Refresh subagent/workflow telemetry as each subagent finishes (resilient to a missed Stop).
+  { event: 'SubagentStop', matcher: null, name: 'subagent-stop', timeout: 20, codex: true, statusMessage: 'wendkeep: subagent telemetry' },
+  // Log plan/task progress into the active session note when a task is marked complete.
+  // codex: TaskCompleted is not in Codex's hook event enum.
+  { event: 'TaskCompleted', matcher: null, name: 'task-log', timeout: 10, statusMessage: 'wendkeep: plan progress' },
+];
+
+export function hookCommand(name) {
+  return `npx wendkeep hook ${name}`;
+}
+
+// Forma node-direta do comando de hook: 1 processo (~100-250ms) em vez dos 3 do npx (cold-start
+// de segundos no Windows). Usada pelos hooks de ALTA FREQUÊNCIA (por prompt / por tool-call)
+// quando o projeto tem wendkeep instalado localmente; o init decide (hookCommandFor).
+export function hookCommandLocal(name) {
+  return `node "${'${CLAUDE_PROJECT_DIR}'}/node_modules/wendkeep/hooks/${name}.mjs"`;
+}
+
+export function hookCommandLocalLegacy(name) {
+  return `node node_modules/wendkeep/hooks/${name}.mjs`;
+}
+
+// Hooks do lifecycle de change (0.31.0) — enforcement do loop a2. Nudges (contexto/aviso/
+// cobrança/captura de plano) e gate (deny/ask no Bash). Separados em dois grupos para
+// preservar a opção futura de gates opt-in; hoje o init wira TODOS por default.
+// preferLocal: alta frequência → invocação node-direta quando houver instalação local.
+export const CHANGE_NUDGE_HOOKS = [
+  { event: 'UserPromptSubmit', matcher: null, name: 'change-context', timeout: 15, order: 10, preferLocal: true, codex: true, statusMessage: 'wendkeep: change ping' },
+  // codex: reads tool_input.file_path, which Codex's apply_patch envelope does not carry.
+  { event: 'PostToolUse', matcher: 'Edit|Write|MultiEdit', name: 'change-warn', timeout: 10, order: 10, preferLocal: true, statusMessage: 'wendkeep: change warn' },
+  // codex: no ExitPlanMode equivalent — update_plan is the running TODO list, not an approval.
+  { event: 'PostToolUse', matcher: 'ExitPlanMode', name: 'plan-capture', timeout: 15, order: 10, preferLocal: true, statusMessage: 'wendkeep: capturing approved plan' },
+  { event: 'Stop', matcher: null, name: 'change-nag', timeout: 15, order: 10, preferLocal: true, codex: true, statusMessage: 'wendkeep: open tasks check' },
+];
+
+export const CHANGE_GATE_HOOKS = [
+  // codex: reads tool_input.command; Codex's exec sends a raw string and exec_command an argv,
+  // so the guard would silently fail OPEN — worse than absent, since the docs would promise it.
+  { event: 'PreToolUse', matcher: 'Bash', name: 'change-guard', timeout: 10, order: 10, preferLocal: true, statusMessage: 'wendkeep: change gate' },
+];
+
+// --- Codex projection ---------------------------------------------------------
+// Codex reads <project>/.codex/hooks.json (PascalCase event keys, same group shape as
+// Claude's settings.json). Only specs that opt in with `codex: true` are projected — the
+// rest carry a `// codex:` comment above them saying why. Three deltas from Claude, each
+// verified against codex-rs and each silent when wrong: the timeout key is `timeoutSec`
+// (`timeout` is not a field and falls through to a 600s default), there is no
+// ${CLAUDE_PROJECT_DIR} so `preferLocal` never applies, and matcher is only honoured on
+// SessionStart (UserPromptSubmit/Stop null it at discovery).
+export const CODEX_MATCHER_EVENTS = new Set(['SessionStart']);
+
+export function codexHookSpecs(specs) {
+  return specs.filter((h) => h.codex === true && !h.command);
+}
+
+export function codexHookEntry(spec) {
+  const entry = { type: 'command', command: hookCommand(spec.name), timeoutSec: spec.timeout };
+  if (spec.statusMessage) entry.statusMessage = spec.statusMessage;
+  return entry;
+}

package/packages/integrations/src/index.mjs

@@ -0,0 +1,6 @@
+export * from './host-hooks.mjs';
+export * from './hook-envelope.mjs';
+export * from './prompt-content.mjs';
+export * from './transcript-usage.mjs';
+export * from './transcripts.mjs';
+export * from './session-identity.mjs';

package/packages/integrations/src/prompt-content.mjs

@@ -0,0 +1,20 @@
+export function isBootstrapPrompt(text = '') {
+  const clean = String(text || '').trim();
+  return clean.startsWith('# AGENTS.md instructions')
+    || clean.startsWith('<environment_context>')
+    || clean.startsWith('<permissions instructions>')
+    || clean.startsWith('<recommended_plugins>')
+    || clean.includes('You are Codex, a coding agent')
+    || clean.startsWith('## Memory');
+}
+
+export function redactSecrets(text) {
+  if (!text) return '';
+  return String(text)
+    .replace(/\b(sk-[A-Za-z0-9_-]{12,})\b/g, '[REDACTED_SECRET]')
+    .replace(/\b(whsec_[A-Za-z0-9_/-]{8,})\b/g, '[REDACTED_SECRET]')
+    .replace(/\b(gh[pousr]_[A-Za-z0-9_]{12,})\b/g, '[REDACTED_SECRET]')
+    .replace(/\b(xox[baprs]-[A-Za-z0-9-]{12,})\b/g, '[REDACTED_SECRET]')
+    .replace(/\b([A-Z0-9_]*(?:TOKEN|SECRET|PASSWORD|API_KEY)[A-Z0-9_]*)\s*[:=]\s*["']?[^"'\s]+/gi, '$1=[REDACTED_SECRET]')
+    .replace(/:\/\/([^:\s/@]+):([^@\s/]+)@/g, '://[REDACTED_SECRET]@');
+}

package/packages/integrations/src/session-identity.mjs

@@ -0,0 +1,171 @@
+function parseJsonLines(content = '') {
+  return String(content || '').split('\n').filter(Boolean).map((line) => {
+    try { return JSON.parse(line); } catch { return null; }
+  }).filter(Boolean);
+}
+
+export function inspectTranscriptIdentityContent(content, { fallbackTranscriptId = '' } = {}) {
+  const lines = parseJsonLines(content);
+  const codexMeta = lines.find((event) => event.type === 'session_meta')?.payload;
+  if (codexMeta) {
+    return {
+      transcriptProvider: 'openai',
+      provider: 'codex',
+      canonicalConversationId: codexMeta.session_id || codexMeta.id || '',
+      transcriptId: codexMeta.id || fallbackTranscriptId,
+      parentConversationId: codexMeta.parent_thread_id || codexMeta.forked_from_id || '',
+    };
+  }
+  const claudeEvent = lines.find((event) => event.sessionId);
+  if (claudeEvent) {
+    return {
+      transcriptProvider: 'anthropic',
+      provider: 'claude',
+      canonicalConversationId: claudeEvent.sessionId,
+      transcriptId: fallbackTranscriptId,
+      parentConversationId: '',
+    };
+  }
+  return {
+    transcriptProvider: 'unknown',
+    provider: 'unknown',
+    canonicalConversationId: '',
+    transcriptId: '',
+    parentConversationId: '',
+  };
+}
+
+function compatible(provider, transcriptProvider) {
+  return (provider === 'codex' && transcriptProvider === 'openai')
+    || (provider === 'claude' && transcriptProvider === 'anthropic');
+}
+
+function canonicalUuid(value = '') {
+  const id = String(value || '').trim().toLowerCase();
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(id) ? id : '';
+}
+
+function pathBasename(path = '') {
+  const normalized = String(path || '').replace(/\\/g, '/');
+  return normalized.slice(normalized.lastIndexOf('/') + 1).replace(/\.jsonl$/i, '');
+}
+
+function providerMatches(entry, provider) {
+  return entry?.provider === provider;
+}
+
+export function transcriptsMatch(a, b) {
+  if (!a || !b) return false;
+  const normalize = (path) => String(path || '').replace(/\\/g, '/').toLowerCase();
+  const normalizedA = normalize(a);
+  const normalizedB = normalize(b);
+  if (normalizedA === normalizedB) return true;
+  const basename = (path) => path.slice(path.lastIndexOf('/') + 1);
+  const basenameA = basename(normalizedA);
+  return Boolean(basenameA) && basenameA === basename(normalizedB);
+}
+
+export function resolveSessionIdentitySnapshot({
+  input = {},
+  provider = 'codex',
+  codexThreadId = '',
+  transcriptPath = '',
+  inspected = {},
+  registry = { version: 2, sessions: {} },
+} = {}) {
+  const explicitTranscriptPath = String(transcriptPath || '');
+  const hookId = input.session_id || input.sessionId || '';
+  const threadId = canonicalUuid(
+    input.codex_thread_id || input.codexThreadId || codexThreadId || '',
+  );
+  const transcriptConversationId = canonicalUuid(inspected.canonicalConversationId);
+
+  if (provider === 'codex' && transcriptConversationId && threadId
+    && transcriptConversationId !== threadId) {
+    return {
+      state: 'deferred',
+      provider,
+      transcriptPath: explicitTranscriptPath,
+      diagnostics: [`CODEX_THREAD_ID diverge do session_id do transcript (${threadId} != ${transcriptConversationId})`],
+    };
+  }
+
+  if (provider === 'codex' && !inspected.canonicalConversationId && threadId) {
+    return {
+      state: 'resolved',
+      provider,
+      canonicalConversationId: threadId,
+      hookSessionId: hookId,
+      transcriptPath: explicitTranscriptPath,
+      transcriptId: explicitTranscriptPath ? pathBasename(explicitTranscriptPath) : threadId,
+      parentConversationId: '',
+      diagnostics: [],
+    };
+  }
+
+  if (provider === 'claude' && hookId && !inspected.canonicalConversationId) {
+    return {
+      state: 'resolved',
+      provider,
+      canonicalConversationId: hookId,
+      hookSessionId: hookId,
+      transcriptPath: explicitTranscriptPath,
+      transcriptId: explicitTranscriptPath ? pathBasename(explicitTranscriptPath) : hookId,
+      parentConversationId: '',
+      diagnostics: [],
+    };
+  }
+
+  if (!explicitTranscriptPath && hookId) {
+    const entry = registry?.sessions?.[hookId];
+    if (entry?.transcript_path && providerMatches(entry, provider)) {
+      return {
+        state: 'resolved',
+        provider,
+        canonicalConversationId: hookId,
+        hookSessionId: hookId,
+        transcriptPath: entry.transcript_path,
+        transcriptId: entry.transcript_id || pathBasename(entry.transcript_path),
+        parentConversationId: '',
+        diagnostics: ['transcript recuperado do SESSION_REGISTRY'],
+      };
+    }
+  }
+
+  if (!explicitTranscriptPath || !inspected.canonicalConversationId) {
+    return {
+      state: 'deferred',
+      provider,
+      transcriptPath: explicitTranscriptPath,
+      diagnostics: ['transcript ausente ou sem identidade canônica'],
+    };
+  }
+  if (!compatible(provider, inspected.transcriptProvider)) {
+    return {
+      state: 'deferred',
+      provider,
+      transcriptPath: explicitTranscriptPath,
+      diagnostics: [`provider ${provider} incompatível com transcript ${inspected.transcriptProvider}`],
+    };
+  }
+
+  const byTranscript = Object.entries(registry?.sessions || {}).find(([, entry]) => {
+    if (!providerMatches(entry, provider)) return false;
+    const paths = [
+      ...(Array.isArray(entry?.transcript_paths) ? entry.transcript_paths : []),
+      entry?.transcript_path,
+    ].filter(Boolean);
+    return paths.some((path) => transcriptsMatch(path, explicitTranscriptPath));
+  });
+
+  return {
+    state: 'resolved',
+    provider,
+    canonicalConversationId: byTranscript?.[0] || inspected.canonicalConversationId,
+    hookSessionId: hookId,
+    transcriptPath: explicitTranscriptPath,
+    transcriptId: inspected.transcriptId,
+    parentConversationId: inspected.parentConversationId,
+    diagnostics: [],
+  };
+}

package/packages/integrations/src/transcript-usage.mjs

@@ -0,0 +1,53 @@
+export function emptyTokenUsage() {
+  return {
+    input: 0,
+    cached: 0,
+    cacheWrite: 0,
+    cacheWrite1h: 0,
+    output: 0,
+    reasoning: 0,
+    total: 0,
+  };
+}
+
+export function normalizeCodexUsage(raw = {}) {
+  const inputAll = Number(raw.input_tokens || 0);
+  const cached = Math.min(Number(raw.cached_input_tokens || 0), inputAll);
+  const output = Number(raw.output_tokens || 0);
+  return {
+    input: inputAll - cached,
+    cached,
+    cacheWrite: 0,
+    cacheWrite1h: 0,
+    output,
+    reasoning: Number(raw.reasoning_output_tokens || 0),
+    total: Number(raw.total_tokens || 0) || inputAll + output,
+  };
+}
+
+export function normalizeClaudeUsage(raw = {}) {
+  const input = Number(raw.input_tokens || 0);
+  const cached = Number(raw.cache_read_input_tokens || 0);
+  const cacheWrite = Number(raw.cache_creation_input_tokens || 0);
+  const cacheWrite1h = Number(raw.cache_creation?.ephemeral_1h_input_tokens || 0);
+  const output = Number(raw.output_tokens || 0);
+  return {
+    input,
+    cached,
+    cacheWrite,
+    cacheWrite1h: Math.min(cacheWrite1h, cacheWrite),
+    output,
+    reasoning: 0,
+    total: input + cached + cacheWrite + output,
+  };
+}
+
+export function addUsage(target, usage) {
+  target.input += usage.input;
+  target.cached += usage.cached;
+  target.cacheWrite += usage.cacheWrite;
+  target.cacheWrite1h += usage.cacheWrite1h;
+  target.output += usage.output;
+  target.reasoning += usage.reasoning;
+  target.total += usage.total;
+}