wendkeep 0.61.0 → 0.63.0

package/packages/harness/src/sensors-core.mjs

@@ -0,0 +1,102 @@
+// hooks/sensors-core.mjs — native sensor runner + evidence gate (Pilar C).
+// Pure-ish: `spawn` is injectable so runs are testable without a shell. Config lives
+// at the PROJECT ROOT (wendkeep.sensors.json); evidence lives per-change in the vault.
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+export const SENSOR_VAULT_ENV = 'WENDKEEP_SENSOR_VAULT';
+
+export function sensorProcessEnv(vaultBase, inherited = process.env) {
+  return {
+    ...inherited,
+    OBSIDIAN_VAULT_PATH: vaultBase,
+    [SENSOR_VAULT_ENV]: vaultBase,
+  };
+}
+
+export function loadSensors(projectRoot, file = 'wendkeep.sensors.json') {
+  return loadSensorsDetailed(projectRoot, file).sensors;
+}
+
+// Missing config and broken config are different failures: absent file usually means
+// wrong cwd (subdirectory), broken JSON means the config itself needs fixing. Collapsing
+// both into [] made every sensor report "sensor não definido" — a misleading diagnosis.
+export function loadSensorsDetailed(projectRoot, file = 'wendkeep.sensors.json') {
+  const path = join(projectRoot, file);
+  if (!existsSync(path)) return { sensors: [], missing: true, error: null, path };
+  try {
+    const data = JSON.parse(readFileSync(path, 'utf8'));
+    return { sensors: Array.isArray(data.sensors) ? data.sensors : [], missing: false, error: null, path };
+  } catch (e) {
+    return { sensors: [], missing: false, error: e.message, path };
+  }
+}
+
+// Climb the directory tree looking for a project marker (wendkeep.sensors.json or
+// .wendkeep.json), like git does with .git — shells in agent harnesses keep their cwd
+// across commands, so verify is often run from a subdirectory.
+export function findProjectRoot(startDir) {
+  let dir = resolve(startDir);
+  for (;;) {
+    if (existsSync(join(dir, 'wendkeep.sensors.json')) || existsSync(join(dir, '.wendkeep.json'))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+export function requiredSensors(tasks) {
+  return [...new Set((tasks || []).flatMap((task) => (
+    Array.isArray(task.sensors) && task.sensors.length ? task.sensors : [task.sensor]
+  )).filter(Boolean))];
+}
+
+export function runSensors(sensors, ids, { spawn = spawnSync, cwd, env, now } = {}) {
+  const byId = Object.fromEntries((sensors || []).map((s) => [s.id, s]));
+  const ts = now || new Date().toISOString();
+  const evidence = [];
+  for (const id of ids) {
+    const s = byId[id];
+    if (!s) { evidence.push({ id, status: 'red', ts, severity: 'critical', note: 'sensor não definido' }); continue; }
+    const r = spawn(s.command, [], { cwd, shell: true, stdio: 'ignore', ...(env ? { env } : {}) });
+    const entry = { id, status: (r.status ?? 1) === 0 ? 'green' : 'red', ts, severity: s.severity || 'critical' };
+    if (s.type === 'mutation' && s.report) {
+      // Delegated mutation (Wave B): read the tool's mutation-testing-elements report and
+      // attach surviving mutants so verify can turn them into fix tasks.
+      try { entry.survivors = parseMutationReport(JSON.parse(readFileSync(join(cwd || '.', s.report), 'utf8'))); }
+      catch { /* report ausente/ilegível — segue só com o exit code */ }
+    }
+    evidence.push(entry);
+  }
+  return evidence;
+}
+
+// Parse a mutation-testing-elements report (Stryker et al.): return surviving mutants
+// (Survived | NoCoverage) as {file, line, mutator}.
+export function parseMutationReport(json) {
+  const out = [];
+  const files = json && json.files ? json.files : {};
+  for (const [file, data] of Object.entries(files)) {
+    for (const m of (data && data.mutants) || []) {
+      if (m.status === 'Survived' || m.status === 'NoCoverage') {
+        out.push({ file, line: m.location && m.location.start ? m.location.start.line : null, mutator: m.mutatorName || 'unknown' });
+      }
+    }
+  }
+  return out;
+}
+
+// A required sensor blocks the gate when it is missing (never verified) or red at a
+// non-warning severity. Warnings are advisory: a red warning does not block archive.
+// Severity comes from the evidence entry (written by runSensors); absent -> critical.
+export function evaluateGate(evidence, requiredIds) {
+  const byId = Object.fromEntries((evidence || []).map((e) => [e.id, e]));
+  const failing = (requiredIds || []).filter((id) => {
+    const e = byId[id];
+    if (!e) return true; // never verified
+    if (e.status === 'green') return false;
+    return (e.severity || 'critical') !== 'warning';
+  });
+  return { ok: failing.length === 0, failing };
+}

package/packages/vault/src/index.mjs

@@ -1,5 +1,6 @@
 export * from './project-vault.mjs';
 export * from './vault-path-safety.mjs';
+export * from './locale.mjs';
 export * from './memory-schema.mjs';
 export * from './memory-mode.mjs';
 export * from './memory-handoff.mjs';

package/packages/vault/src/locale.mjs

@@ -0,0 +1,74 @@
+// packages/vault/src/locale.mjs — canonical vault locale and folder taxonomy.
+// The locale is a property of the VAULT,
+// stored at <vault>/.brain/config.json ({ "locale": "en" }); absent = pt-BR (full backward
+// compat). Parsers stay bilingual everywhere; only RENDERING follows the locale.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const LOCALES = {
+  'pt-BR': {
+    id: 'pt-BR',
+    folders: {
+      inbox: '00-Inbox',
+      project: '01-Projeto',
+      sessions: '02-Sessões',
+      linear: '03-Linear',
+      decisions: '04-Decisões',
+      bugs: '05-Bugs',
+      learnings: '06-Aprendizados',
+      specs: '07-Specs',
+      changes: '08-Mudanças',
+    },
+    months: ['01-JAN', '02-FEV', '03-MAR', '04-ABR', '05-MAI', '06-JUN', '07-JUL', '08-AGO', '09-SET', '10-OUT', '11-NOV', '12-DEZ'],
+    reqHeading: 'Requisito',
+    fixTaskVerb: 'mata mutante',
+    coreSections: ['Preferências do Usuário', 'Padrões Ativos', 'Pendências Abertas'],
+  },
+  en: {
+    id: 'en',
+    folders: {
+      inbox: '00-Inbox',
+      project: '01-Project',
+      sessions: '02-Sessions',
+      linear: '03-Linear',
+      decisions: '04-Decisions',
+      bugs: '05-Bugs',
+      learnings: '06-Learnings',
+      specs: '07-Specs',
+      changes: '08-Changes',
+    },
+    months: ['01-JAN', '02-FEB', '03-MAR', '04-APR', '05-MAY', '06-JUN', '07-JUL', '08-AUG', '09-SEP', '10-OCT', '11-NOV', '12-DEC'],
+    reqHeading: 'Requirement',
+    fixTaskVerb: 'kill mutant',
+    coreSections: ['User Preferences', 'Active Patterns', 'Open Items'],
+  },
+};
+
+export const DEFAULT_LOCALE = 'pt-BR';
+
+// Per-process cache: one vault per process (hooks + CLI), reads are hot paths.
+const cache = new Map();
+
+export function getLocale(vaultBase) {
+  if (!vaultBase) return LOCALES[DEFAULT_LOCALE];
+  const key = String(vaultBase);
+  if (cache.has(key)) return cache.get(key);
+  let id = DEFAULT_LOCALE;
+  try {
+    const data = JSON.parse(readFileSync(join(key, '.brain', 'config.json'), 'utf8'));
+    if (data.locale && LOCALES[data.locale]) id = data.locale;
+  } catch { /* sem config = pt-BR */ }
+  const loc = LOCALES[id];
+  cache.set(key, loc);
+  return loc;
+}
+
+// Test hook: drop the memoized entry (tests rewrite config.json under one tmpdir).
+export function clearLocaleCache() {
+  cache.clear();
+}
+
+// The full vault taxonomy for a locale (folders + fixed entries), in creation order.
+export function vaultFolders(loc) {
+  return [...Object.values(loc.folders), 'Templates', '.brain'];
+}