hive-lite 0.1.0

package/src/lib/evidence.js

@@ -0,0 +1,230 @@
+const { validationStatus } = require('./risk');
+const {
+  inferRoleFromPath,
+  isInternalBehaviorRole,
+  isUiManualRole,
+  normalizeRole,
+} = require('./roles');
+
+function areaForChange(map, change) {
+  const areaId = change.source && change.source.contextPacketId && change.scope && change.scope.matchedAreas
+    ? change.scope.matchedAreas[0]
+    : null;
+  if (areaId) return map.areas.find((area) => area.id === areaId) || null;
+  const ids = (change.scope && change.scope.matchedAreas) || [];
+  return ids.length ? map.areas.find((area) => area.id === ids[0]) || null : null;
+}
+
+function roleForFile(area, file) {
+  const entry = area && Array.isArray(area.entrypoints)
+    ? area.entrypoints.find((item) => item.path === file)
+    : null;
+  if (entry && entry.role) return normalizeRole(entry.role) || 'unknown';
+  return inferRoleFromPath(file);
+}
+
+function changedRoles(change, area) {
+  const seen = new Map();
+  for (const file of change.diff.changedFiles || []) {
+    const filePath = file.path || file;
+    const role = roleForFile(area, filePath);
+    if (!seen.has(role)) seen.set(role, []);
+    seen.get(role).push(filePath);
+  }
+  return [...seen.entries()].map(([role, files]) => ({ role, files }));
+}
+
+function validationResultForProfile(change, profile) {
+  return ((change.validation && change.validation.results) || [])
+    .find((result) => result.profile === profile && result.status === 'passed');
+}
+
+function manualEvidence(change) {
+  return ((change.validation && change.validation.results) || [])
+    .filter((result) => result.type === 'manual' && result.status === 'passed');
+}
+
+function commandEvidence(change) {
+  return ((change.validation && change.validation.results) || [])
+    .filter((result) => result.type === 'command' && result.status === 'passed');
+}
+
+function profileMeta(map, id) {
+  return (map.validationProfiles || []).find((profile) => profile.id === id) || {};
+}
+
+function commandLooksFocusedTest(command, profileId, meta) {
+  const text = [command, profileId, meta.evidence_type, meta.evidenceType, meta.description].filter(Boolean).join(' ').toLowerCase();
+  return /\b(test|tests|spec|vitest|jest|playwright|e2e|smoke|golden)\b/.test(text)
+    || text.includes('focused_test')
+    || text.includes('existing_tests');
+}
+
+function hasFocusedTestEvidence(change, map) {
+  return commandEvidence(change).some((result) => commandLooksFocusedTest(result.command, result.profile, profileMeta(map, result.profile)));
+}
+
+function requiredValidationMissing(change) {
+  const plan = (change.validation && change.validation.plan) || [];
+  if (!plan.some((item) => item.required !== false && item.type !== 'manual' && item.command)) return false;
+  return validationStatus(change) === 'not_run';
+}
+
+function hasManualEvidenceFor(change, profiles) {
+  if (!profiles.length) return manualEvidence(change).length > 0;
+  return profiles.some((profile) => validationResultForProfile(change, profile));
+}
+
+function normalizeList(values) {
+  return Array.isArray(values) ? values.filter(Boolean) : [];
+}
+
+function reviewReasonAllowed(verification) {
+  return !verification || verification.review_with_reason_allowed !== false;
+}
+
+function evaluateEvidencePolicy(change, map) {
+  const area = areaForChange(map, change);
+  const verification = (area && area.verification) || {};
+  const roles = changedRoles(change, area);
+  const roleNames = roles.map((item) => item.role);
+  const reasons = [];
+  const required = ['scope_clean'];
+  const recommended = [];
+  const missing = [];
+  const nextActions = [];
+  const manualProfiles = normalizeList(verification.manual_profiles);
+  const focusedRecommended = new Set([
+    ...normalizeList(verification.focused_test_recommended_for_roles),
+    ...normalizeList(verification.focusedTestRecommendedForRoles),
+  ].map((role) => normalizeRole(role)).filter(Boolean));
+  const focusedRequired = new Set([
+    ...normalizeList(verification.focused_test_required_for_roles),
+    ...normalizeList(verification.focusedTestRequiredForRoles),
+  ].map((role) => normalizeRole(role)).filter(Boolean));
+
+  let changeClass = 'unknown';
+  let verdict = 'acceptable';
+
+  if (change.scope.status === 'violation') {
+    verdict = 'blocked';
+    missing.push('scope_clean');
+    reasons.push('Scope violation blocks acceptance.');
+  } else if (change.scope.status === 'needs_review' || change.scope.status === 'unknown') {
+    verdict = 'needs_review_reason';
+    missing.push('review_reason');
+    reasons.push(`Scope is ${change.scope.status}.`);
+  }
+
+  if (change.risk && change.risk.verdict === 'blocked') {
+    verdict = 'blocked';
+    reasons.push(...(change.risk.blockingReasons || []));
+  }
+
+  const validation = validationStatus(change);
+  if (validation === 'failed') {
+    verdict = 'blocked';
+    missing.push('validation_passed');
+    reasons.push('Validation failed.');
+  } else if (requiredValidationMissing(change)) {
+    verdict = verdict === 'blocked' ? verdict : 'needs_validation';
+    missing.push('required_validation');
+    reasons.push('Required validation has not run.');
+  }
+
+  const manualLike = roleNames.some((role) => isUiManualRole(role));
+  const internalLike = roleNames.some((role) => isInternalBehaviorRole(role))
+    || roleNames.some((role) => focusedRecommended.has(role) || focusedRequired.has(role));
+
+  if (manualLike && verification.direct_manual_allowed !== false) {
+    changeClass = 'direct_manual_verifiable';
+    const profiles = manualProfiles.length ? manualProfiles : ['manual-verification'];
+    required.push(`manual:${profiles.join('|')}`);
+    if (validation !== 'not_run' && validation !== 'failed' && verdict === 'acceptable' && !hasManualEvidenceFor(change, manualProfiles)) {
+      verdict = 'needs_manual_verification';
+      missing.push('manual_verification');
+      reasons.push('This change is directly manually verifiable, but no manual evidence was recorded.');
+      nextActions.push({
+        kind: 'manual_validation',
+        command: `hive-lite validate ${change.id} --manual ${profiles[0]} --result passed --note "<what you verified>"`,
+      });
+    }
+  } else if (internalLike) {
+    changeClass = 'internal_logic';
+    const requiresFocused = roleNames.some((role) => focusedRequired.has(role));
+    if (requiresFocused) required.push('focused_test');
+    else recommended.push('focused_test');
+    if (validation !== 'not_run' && validation !== 'failed' && verdict === 'acceptable' && !hasFocusedTestEvidence(change, map)) {
+      verdict = requiresFocused ? 'evidence_insufficient' : 'needs_review_reason';
+      missing.push(requiresFocused ? 'focused_test' : 'focused_test_or_review_reason');
+      reasons.push('This change touches internal behavior; build/typecheck alone may not prove behavior.');
+      nextActions.push({
+        kind: 'focused_test',
+        message: 'Ask the coding agent to add or update a focused automated verification when practical.',
+      });
+      if (reviewReasonAllowed(verification)) {
+        nextActions.push({
+          kind: 'accept_reviewed',
+          command: `hive-lite accept ${change.id} --reviewed --reason "<why the evidence is sufficient>"`,
+        });
+      }
+    }
+  } else if (!area || !area.verification) {
+    changeClass = 'unknown_policy';
+    if (validation !== 'not_run' && validation !== 'failed' && verdict === 'acceptable') {
+      verdict = 'needs_review_reason';
+      missing.push('review_reason');
+      reasons.push('No verification policy is configured for this area.');
+    }
+  }
+
+  if (change.risk && change.risk.reviewReasons && change.risk.reviewReasons.length > 0 && verdict === 'acceptable') {
+    verdict = 'needs_review_reason';
+    missing.push('review_reason');
+    reasons.push(...change.risk.reviewReasons);
+  }
+
+  if (verdict === 'needs_validation') {
+    nextActions.push({ kind: 'validate', command: `hive-lite validate ${change.id}` });
+  }
+  if ((verdict === 'needs_review_reason' || verdict === 'evidence_insufficient') && reviewReasonAllowed(verification)) {
+    nextActions.push({
+      kind: 'accept_reviewed',
+      command: `hive-lite accept ${change.id} --reviewed --reason "<why the evidence is sufficient>"`,
+    });
+  }
+  if (verdict === 'acceptable') {
+    nextActions.push({ kind: 'accept', command: `hive-lite accept ${change.id}` });
+  }
+
+  return {
+    version: 1,
+    class: changeClass,
+    verdict,
+    areaId: area ? area.id : null,
+    changedRoles: roles,
+    required: [...new Set(required)],
+    recommended: [...new Set(recommended)],
+    missing: [...new Set(missing)],
+    manualVerification: {
+      allowed: Boolean(manualLike && verification.direct_manual_allowed !== false),
+      profiles: manualProfiles.length ? manualProfiles : (manualLike ? ['manual-verification'] : []),
+      recorded: manualEvidence(change).map((item) => ({
+        profile: item.profile,
+        note: item.note || '',
+      })),
+    },
+    focusedTest: {
+      recommended: recommended.includes('focused_test'),
+      present: hasFocusedTestEvidence(change, map),
+    },
+    reviewWithReasonAllowed: reviewReasonAllowed(verification),
+    reasons: [...new Set(reasons)],
+    nextActions,
+  };
+}
+
+module.exports = {
+  evaluateEvidencePolicy,
+  inferRole: inferRoleFromPath,
+};

package/src/lib/fsx.js

@@ -0,0 +1,54 @@
+const fs = require('fs');
+const path = require('path');
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function readText(file) {
+  return fs.readFileSync(file, 'utf8');
+}
+
+function writeText(file, value) {
+  ensureDir(path.dirname(file));
+  fs.writeFileSync(file, value);
+}
+
+function readJson(file) {
+  return JSON.parse(readText(file));
+}
+
+function writeJson(file, value) {
+  writeText(file, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function exists(file) {
+  return fs.existsSync(file);
+}
+
+function listDirs(dir) {
+  if (!exists(dir)) return [];
+  return fs.readdirSync(dir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name);
+}
+
+function appendIfMissing(file, lines) {
+  const existing = exists(file) ? readText(file) : '';
+  const additions = lines.filter((line) => !existing.split(/\r?\n/).includes(line));
+  if (additions.length === 0) return false;
+  const prefix = existing.length > 0 && !existing.endsWith('\n') ? '\n' : '';
+  writeText(file, `${existing}${prefix}${additions.join('\n')}\n`);
+  return true;
+}
+
+module.exports = {
+  appendIfMissing,
+  ensureDir,
+  exists,
+  listDirs,
+  readJson,
+  readText,
+  writeJson,
+  writeText,
+};

package/src/lib/git.js

@@ -0,0 +1,128 @@
+const cp = require('child_process');
+const path = require('path');
+
+function runGit(args, options = {}) {
+  return cp.execFileSync('git', args, {
+    cwd: options.cwd || process.cwd(),
+    encoding: 'utf8',
+    stdio: options.stdio || ['ignore', 'pipe', 'pipe'],
+  }).trim();
+}
+
+function runGitRaw(args, options = {}) {
+  return cp.execFileSync('git', args, {
+    cwd: options.cwd || process.cwd(),
+    encoding: 'utf8',
+    stdio: options.stdio || ['ignore', 'pipe', 'pipe'],
+  });
+}
+
+function tryGit(args, options = {}) {
+  try {
+    return runGit(args, options);
+  } catch {
+    return '';
+  }
+}
+
+function repoRoot(cwd = process.cwd()) {
+  const root = tryGit(['rev-parse', '--show-toplevel'], { cwd });
+  return root || cwd;
+}
+
+function isGitRepo(cwd = process.cwd()) {
+  return tryGit(['rev-parse', '--is-inside-work-tree'], { cwd }) === 'true';
+}
+
+function requireGitRepo(cwd = process.cwd(), label = 'Hive Lite') {
+  if (!isGitRepo(cwd)) {
+    throw new Error(`${label} requires a git repository. Switch to the correct repo root, or initialize and commit the project manually before using Hive Lite.`);
+  }
+  return repoRoot(cwd);
+}
+
+function currentBranch(root) {
+  return tryGit(['branch', '--show-current'], { cwd: root }) || null;
+}
+
+function currentHead(root) {
+  return tryGit(['rev-parse', 'HEAD'], { cwd: root }) || null;
+}
+
+function statusLines(root) {
+  let output = '';
+  try {
+    output = runGitRaw(['status', '--porcelain'], { cwd: root });
+  } catch {
+    output = '';
+  }
+  return output ? output.split(/\r?\n/).filter(Boolean) : [];
+}
+
+function parseStatusLine(line) {
+  const status = line.slice(0, 2);
+  let file = line.slice(3).trim();
+  if (file.includes(' -> ')) file = file.split(' -> ').pop().trim();
+  return { status, path: file.replace(/^"|"$/g, '') };
+}
+
+function changedFiles(root) {
+  const seen = new Map();
+  for (const line of statusLines(root)) {
+    const parsed = parseStatusLine(line);
+    seen.set(parsed.path, {
+      path: parsed.path,
+      status: parsed.status.includes('?') ? 'untracked' : 'modified',
+    });
+  }
+  return [...seen.values()].sort((a, b) => a.path.localeCompare(b.path));
+}
+
+function diffFromHead(root) {
+  return runGitRaw(['diff', '--binary', 'HEAD', '--'], { cwd: root });
+}
+
+function grep(root, term, max = 20) {
+  if (!term || term.length < 2) return [];
+  const output = tryGit(['grep', '-n', '-i', '--', term], { cwd: root });
+  if (!output) return [];
+  return output.split(/\r?\n/)
+    .filter(Boolean)
+    .slice(0, max)
+    .map((line) => {
+      const first = line.indexOf(':');
+      const second = line.indexOf(':', first + 1);
+      if (first === -1 || second === -1) return { path: line, line: null, text: '' };
+      return {
+        path: line.slice(0, first),
+        line: Number(line.slice(first + 1, second)),
+        text: line.slice(second + 1).trim(),
+      };
+    });
+}
+
+function commitAll(root, message) {
+  runGit(['add', '-A'], { cwd: root });
+  runGit(['commit', '-m', message], { cwd: root, stdio: ['ignore', 'pipe', 'pipe'] });
+  return currentHead(root);
+}
+
+function displayPath(root, file) {
+  return path.relative(root, file).replace(/\\/g, '/');
+}
+
+module.exports = {
+  changedFiles,
+  commitAll,
+  currentBranch,
+  currentHead,
+  diffFromHead,
+  displayPath,
+  grep,
+  isGitRepo,
+  repoRoot,
+  requireGitRepo,
+  runGit,
+  statusLines,
+  tryGit,
+};

package/src/lib/glob.js

@@ -0,0 +1,47 @@
+function escapeRegex(value) {
+  return value.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
+}
+
+function globToRegExp(pattern) {
+  const normalized = pattern.replace(/\\/g, '/').replace(/^\.\//, '');
+  let source = '';
+  for (let i = 0; i < normalized.length; i += 1) {
+    const ch = normalized[i];
+    const next = normalized[i + 1];
+    if (ch === '*' && next === '*') {
+      const after = normalized[i + 2];
+      if (after === '/') {
+        source += '(?:.*\\/)?';
+        i += 2;
+      } else {
+        source += '.*';
+        i += 1;
+      }
+    } else if (ch === '*') {
+      source += '[^/]*';
+    } else {
+      source += escapeRegex(ch);
+    }
+  }
+  return new RegExp(`^${source}$`);
+}
+
+function matchesPattern(file, pattern) {
+  const normalized = file.replace(/\\/g, '/').replace(/^\.\//, '');
+  const cleanPattern = String(pattern || '').trim().replace(/^\.\//, '');
+  if (!cleanPattern) return false;
+  if (!cleanPattern.includes('*')) {
+    const prefix = cleanPattern.replace(/\/+$/, '');
+    return normalized === prefix || normalized.startsWith(`${prefix}/`);
+  }
+  return globToRegExp(cleanPattern).test(normalized);
+}
+
+function firstPatternMatch(file, patterns) {
+  return (patterns || []).find((pattern) => matchesPattern(file, typeof pattern === 'string' ? pattern : pattern.pattern));
+}
+
+module.exports = {
+  firstPatternMatch,
+  matchesPattern,
+};