hive-lite 0.1.0

package/src/lib/status.js

@@ -0,0 +1,344 @@
+const { createHash } = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { changedFiles, currentBranch, currentHead, diffFromHead, isGitRepo, repoRoot } = require('./git');
+const { latestChangeId, loadChange } = require('./change');
+const { exists, readJson } = require('./fsx');
+const { hiveDir } = require('./map');
+
+function sha256(value) {
+  return createHash('sha256').update(value || '').digest('hex');
+}
+
+function diffHash(text) {
+  return `sha256:${sha256(text)}`;
+}
+
+function accepted(change) {
+  return change && change.humanDecision && change.humanDecision.status === 'accepted';
+}
+
+function committed(change) {
+  return Boolean(change && change.humanDecision && change.humanDecision.commit);
+}
+
+function latestChange(root) {
+  const id = latestChangeId(root);
+  if (!id) return { id: null, change: null };
+  try {
+    return { id, change: loadChange(root, id) };
+  } catch {
+    return { id, change: null };
+  }
+}
+
+function acceptedChangesBySplit(root) {
+  const dir = path.join(hiveDir(root), 'changes');
+  const accepted = new Map();
+  if (!exists(dir)) return accepted;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !entry.name.startsWith('chg_')) continue;
+    const file = path.join(dir, entry.name, 'change.json');
+    if (!exists(file)) continue;
+    try {
+      const change = readJson(file);
+      const origin = change.originSplit || {};
+      if (!origin.splitId || !origin.phaseId) continue;
+      if (!change.humanDecision || change.humanDecision.status !== 'accepted') continue;
+      const bySplit = accepted.get(origin.splitId) || new Map();
+      const list = bySplit.get(origin.phaseId) || [];
+      list.push({
+        changeId: change.id,
+        commit: change.humanDecision.commit || null,
+      });
+      bySplit.set(origin.phaseId, list);
+      accepted.set(origin.splitId, bySplit);
+    } catch {
+      // Ignore malformed historical change records.
+    }
+  }
+  return accepted;
+}
+
+function sortSplitNotes(notes) {
+  return notes.sort((a, b) => (
+    String(b.createdAt).localeCompare(String(a.createdAt)) || String(b.id).localeCompare(String(a.id))
+  ));
+}
+
+function splitIsComplete(split) {
+  const progress = split.derivedProgress || {};
+  return split.phaseCount > 0 && (progress.remainingPhases || []).length === 0;
+}
+
+function splitHasAcceptedProgress(split) {
+  const progress = split.derivedProgress || {};
+  return (progress.acceptedPhases || []).length > 0;
+}
+
+function splitHasReadyPhase(split) {
+  const progress = split.derivedProgress || {};
+  return (progress.readyPhases || []).length > 0;
+}
+
+function splitSummaryItem(split) {
+  if (!split) return null;
+  return {
+    id: split.id,
+    createdAt: split.createdAt,
+    originalIntent: split.originalIntent,
+    suggestedNextPhase: split.suggestedNextPhase || null,
+  };
+}
+
+function primaryRecentSplitNote(shownNotes) {
+  return shownNotes.find(splitHasReadyPhase) || shownNotes[0] || null;
+}
+
+function defaultVisibleSplitNotes(notes, limit) {
+  const active = notes.filter((split) => (
+    !splitIsComplete(split)
+    && splitHasAcceptedProgress(split)
+    && ((split.derivedProgress.remainingPhases || []).length > 0)
+  ));
+  if (active.length > 0) return active.slice(0, limit);
+
+  return notes
+    .filter((split) => !splitIsComplete(split) && splitHasReadyPhase(split))
+    .slice(0, Math.min(limit, 1));
+}
+
+function splitNoteSummary(allNotes, shownNotes, policy) {
+  const shown = new Set(shownNotes.map((split) => split.id));
+  const primary = primaryRecentSplitNote(shownNotes);
+  const activeWithProgress = allNotes.filter((split) => !splitIsComplete(split) && splitHasAcceptedProgress(split));
+  return {
+    total: allNotes.length,
+    shown: shownNotes.length,
+    suppressed: allNotes.filter((split) => !shown.has(split.id)).length,
+    activeWithProgress: activeWithProgress.length,
+    unstartedCandidates: allNotes.filter((split) => !splitIsComplete(split) && !splitHasAcceptedProgress(split)).length,
+    completed: allNotes.filter(splitIsComplete).length,
+    primaryRecentSplitNote: splitSummaryItem(primary),
+    otherActiveSplitNotes: activeWithProgress
+      .filter((split) => !primary || split.id !== primary.id)
+      .map(splitSummaryItem),
+    policy,
+  };
+}
+
+function emptySplitNoteSummary(policy = 'active_progress_or_latest_unstarted') {
+  return {
+    total: 0,
+    shown: 0,
+    suppressed: 0,
+    activeWithProgress: 0,
+    unstartedCandidates: 0,
+    completed: 0,
+    primaryRecentSplitNote: null,
+    otherActiveSplitNotes: [],
+    policy,
+  };
+}
+
+function splitNotesOverview(root, options = {}) {
+  const dir = path.join(hiveDir(root), 'context', 'splits');
+  const includeAll = Boolean(options.includeAll);
+  const policy = includeAll ? 'all' : 'active_progress_or_latest_unstarted';
+  if (!exists(dir)) return { notes: [], summary: emptySplitNoteSummary(policy) };
+  const accepted = acceptedChangesBySplit(root);
+  const allNotes = sortSplitNotes(fs.readdirSync(dir, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && entry.name.endsWith('.json') && entry.name.startsWith('split_'))
+    .map((entry) => {
+      const file = path.join(dir, entry.name);
+      try {
+        const note = readJson(file);
+        const phases = Array.isArray(note.phases) ? note.phases : [];
+        const acceptedForSplit = accepted.get(note.id) || new Map();
+        const acceptedPhases = phases.filter((phase) => acceptedForSplit.has(phase.id)).map((phase) => phase.id);
+        const remaining = phases.filter((phase) => !acceptedForSplit.has(phase.id));
+        const ready = [];
+        const waiting = [];
+        for (const phase of remaining) {
+          const required = ((phase.preconditions || {}).requiredAcceptedPhases || []);
+          const missing = required.filter((phaseId) => !acceptedForSplit.has(phaseId));
+          const item = {
+            phaseId: phase.id,
+            title: phase.title,
+            findIntent: phase.findIntent,
+            missingRequiredAcceptedPhases: missing,
+          };
+          if (missing.length) waiting.push(item);
+          else ready.push(item);
+        }
+        return {
+          id: note.id,
+          createdAt: note.createdAt || fs.statSync(file).mtime.toISOString(),
+          originalIntent: note.source ? note.source.originalIntent || '' : note.originalIntent || '',
+          markdownPath: path.relative(root, path.join(dir, `${note.id}.md`)).replace(/\\/g, '/'),
+          phaseCount: phases.length,
+          derivedProgress: {
+            acceptedPhases,
+            remainingPhases: remaining.map((phase) => phase.id),
+            readyPhases: ready,
+            waitingPhases: waiting,
+            isComplete: phases.length > 0 && remaining.length === 0,
+            hasAcceptedProgress: acceptedPhases.length > 0,
+          },
+          suggestedNextPhase: ready[0] || null,
+        };
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean));
+  const limit = includeAll ? allNotes.length : 5;
+  const notes = includeAll ? allNotes : defaultVisibleSplitNotes(allNotes, limit);
+  return {
+    notes,
+    summary: splitNoteSummary(allNotes, notes, policy),
+  };
+}
+
+function action(kind, label, command, description) {
+  return { kind, label, command, description };
+}
+
+function actionsFor(state, latestId, diffMatches) {
+  if (state === 'repo_setup_required') {
+    return [
+      action('stop', 'Stop', null, 'Hive Lite requires a git repository before it can create Context Packets or Change Records.'),
+      action('change_directory', 'Switch to the correct git repo root', null, 'If this project already has git, open the repository root and rerun Hive Lite.'),
+      action('manual_git_setup', 'Set up git manually', null, 'If this is a new project, review .gitignore, initialize git, and create an initial commit yourself before running Hive Lite.'),
+    ];
+  }
+  if (state === 'clean') {
+    return [
+      action('start_requirement', 'Start a Hive Lite requirement', 'hive-lite find "<intent>" --json', 'The worktree is clean enough to generate a new Context Packet.'),
+    ];
+  }
+  if (state === 'unmanaged_dirty') {
+    return [
+      action('commit', 'Commit current changes', 'git add -A && git commit -m "<message>"', 'Creates a clean git boundary before starting a new requirement.'),
+      action('stash', 'Stash current changes', 'git stash push -u -m "wip before hive-lite"', 'Temporarily clears the worktree without accepting the changes.'),
+      action('worktree', 'Start in a separate worktree', 'git worktree add ../<repo>-<topic> -b <branch-name>', 'Use this when current work must remain unfinished.'),
+      action('stop', 'Stop', null, 'Do not start a new Hive Lite requirement from a dirty worktree.'),
+    ];
+  }
+  if (state === 'in_progress') {
+    const refresh = diffMatches ? [] : [
+      action('refresh_change', 'Refresh the existing Change Record', `hive-lite check ${latestId}`, 'The current diff changed since the latest Change Record was captured.'),
+    ];
+    return [
+      ...refresh,
+      action('validate', 'Validate existing Hive change', `hive-lite validate ${latestId}`, 'Run the validation plan recorded for the current change.'),
+      action('accept_commit', 'Accept and commit existing Hive change', `hive-lite accept ${latestId} --commit -m "<message>"`, 'Finish the current Hive change and return the worktree to clean.'),
+      action('worktree', 'Start in a separate worktree', 'git worktree add ../<repo>-<topic> -b <branch-name>', 'Use this when current work must remain unfinished.'),
+      action('stop', 'Stop', null, 'Do not start a new Hive Lite requirement until the current change is finished or isolated.'),
+    ];
+  }
+  if (state === 'accepted_uncommitted') {
+    return [
+      action('accept_commit', 'Commit accepted Hive change', `hive-lite accept ${latestId} --commit -m "<message>"`, 'Creates the git boundary for the accepted change.'),
+      action('worktree', 'Start in a separate worktree', 'git worktree add ../<repo>-<topic> -b <branch-name>', 'Use this when the accepted change must remain uncommitted here.'),
+      action('stop', 'Stop', null, 'Do not start a new Hive Lite requirement until the accepted change is committed or isolated.'),
+    ];
+  }
+  return [];
+}
+
+function evaluateWorkspaceStatus(cwd, options = {}) {
+  if (!isGitRepo(cwd)) {
+    const root = path.resolve(cwd);
+    const state = 'repo_setup_required';
+    return {
+      version: 1,
+      root,
+      repo: {
+        isGitRepo: false,
+        setupRequired: true,
+      },
+      branch: null,
+      head: null,
+      worktree: {
+        status: 'no_git',
+        dirty: false,
+        changedFiles: [],
+        currentDiffHash: null,
+      },
+      hive: {
+        state,
+        reason: 'Current directory is not inside a git worktree. Hive Lite requires git for diff, baseline, Change Record, and accept boundaries.',
+        latestChange: null,
+      },
+      canStartNewRequirement: false,
+      recommendedActions: actionsFor(state, null, false),
+      recentSplitNotes: [],
+      splitNoteSummary: emptySplitNoteSummary(options.all ? 'all' : 'active_progress_or_latest_unstarted'),
+    };
+  }
+
+  const root = repoRoot(cwd);
+  const files = changedFiles(root);
+  const dirty = files.length > 0;
+  const currentDiff = dirty ? diffFromHead(root) : '';
+  const currentDiffHash = dirty ? diffHash(currentDiff) : null;
+  const latest = latestChange(root);
+  const latestDiffHash = latest.change && latest.change.diff ? latest.change.diff.diffHash : null;
+  const diffMatches = Boolean(dirty && latestDiffHash && currentDiffHash === latestDiffHash);
+
+  let state = dirty ? 'unmanaged_dirty' : 'clean';
+  let reason = dirty
+    ? 'Working tree has dirty files that are not known to be an accepted or in-progress Hive change.'
+    : 'Working tree is clean.';
+
+  if (dirty && latest.change) {
+    if (accepted(latest.change) && !committed(latest.change) && diffMatches) {
+      state = 'accepted_uncommitted';
+      reason = 'The dirty diff matches the latest accepted Hive change, but no commit was created.';
+    } else if (!accepted(latest.change)) {
+      state = 'in_progress';
+      reason = diffMatches
+        ? 'The dirty diff matches the latest in-progress Hive Change Record.'
+        : 'There is an in-progress Hive Change Record, but the working diff has changed since it was captured.';
+    } else if (accepted(latest.change) && !committed(latest.change) && !diffMatches) {
+      reason = 'The latest Hive change was accepted without commit, but the current dirty diff no longer matches it.';
+    }
+  }
+
+  const latestSummary = latest.change ? {
+    id: latest.id,
+    verdict: latest.change.risk ? latest.change.risk.verdict : null,
+    validationStatus: latest.change.validation ? latest.change.validation.status : null,
+    humanDecision: latest.change.humanDecision || null,
+    diffHash: latestDiffHash,
+    currentDiffMatchesLatestChange: diffMatches,
+  } : null;
+  const splitNotes = splitNotesOverview(root, { includeAll: options.all });
+
+  return {
+    version: 1,
+    root,
+    branch: currentBranch(root),
+    head: currentHead(root),
+    worktree: {
+      status: dirty ? 'dirty' : 'clean',
+      dirty,
+      changedFiles: files,
+      currentDiffHash,
+    },
+    hive: {
+      state,
+      reason,
+      latestChange: latestSummary,
+    },
+    canStartNewRequirement: state === 'clean',
+    recommendedActions: actionsFor(state, latest.id, diffMatches),
+    recentSplitNotes: splitNotes.notes,
+    splitNoteSummary: splitNotes.summary,
+  };
+}
+
+module.exports = {
+  evaluateWorkspaceStatus,
+};

package/src/lib/yaml.js

@@ -0,0 +1,223 @@
+function stripComment(line) {
+  let quote = null;
+  for (let i = 0; i < line.length; i += 1) {
+    const ch = line[i];
+    if ((ch === '"' || ch === "'") && line[i - 1] !== '\\') {
+      quote = quote === ch ? null : quote || ch;
+    }
+    if (ch === '#' && !quote) {
+      return line.slice(0, i);
+    }
+  }
+  return line;
+}
+
+function preprocess(input) {
+  return input.split(/\r?\n/)
+    .map((raw) => {
+      const withoutComment = stripComment(raw).replace(/\s+$/g, '');
+      const text = withoutComment.trim();
+      if (!text) return null;
+      return {
+        indent: withoutComment.match(/^ */)[0].length,
+        text,
+      };
+    })
+    .filter(Boolean);
+}
+
+function splitInlineArray(value) {
+  const items = [];
+  let current = '';
+  let quote = null;
+  for (let i = 0; i < value.length; i += 1) {
+    const ch = value[i];
+    if ((ch === '"' || ch === "'") && value[i - 1] !== '\\') {
+      quote = quote === ch ? null : quote || ch;
+      current += ch;
+      continue;
+    }
+    if (ch === ',' && !quote) {
+      items.push(current.trim());
+      current = '';
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) items.push(current.trim());
+  return items;
+}
+
+function parseScalar(value) {
+  const text = value.trim();
+  if (text === '[]') return [];
+  if (text === '{}') return {};
+  if (text === 'null' || text === '~') return null;
+  if (text === 'true') return true;
+  if (text === 'false') return false;
+  if (/^-?\d+(\.\d+)?$/.test(text)) return Number(text);
+  if ((text.startsWith('"') && text.endsWith('"')) || (text.startsWith("'") && text.endsWith("'"))) {
+    if (text.startsWith('"')) return JSON.parse(text);
+    return text.slice(1, -1).replace(/''/g, "'");
+  }
+  if (text.startsWith('[') && text.endsWith(']')) {
+    const inner = text.slice(1, -1).trim();
+    if (!inner) return [];
+    return splitInlineArray(inner).map(parseScalar);
+  }
+  return text;
+}
+
+function splitKeyValue(text) {
+  let quote = null;
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    if ((ch === '"' || ch === "'") && text[i - 1] !== '\\') {
+      quote = quote === ch ? null : quote || ch;
+    }
+    if (ch === ':' && !quote) {
+      return [text.slice(0, i).trim(), text.slice(i + 1).trim()];
+    }
+  }
+  return null;
+}
+
+function parseObject(lines, start, indent) {
+  const result = {};
+  let index = start;
+  while (index < lines.length) {
+    const line = lines[index];
+    if (line.indent < indent) break;
+    if (line.indent > indent) {
+      throw new Error(`unexpected indentation near "${line.text}"`);
+    }
+    if (line.text.startsWith('- ')) break;
+
+    const pair = splitKeyValue(line.text);
+    if (!pair || !pair[0]) throw new Error(`expected key: value near "${line.text}"`);
+    const [key, rest] = pair;
+    index += 1;
+    if (rest) {
+      result[key] = parseScalar(rest);
+      continue;
+    }
+
+    if (index >= lines.length || lines[index].indent <= indent) {
+      result[key] = null;
+      continue;
+    }
+    const parsed = parseBlock(lines, index, lines[index].indent);
+    result[key] = parsed.value;
+    index = parsed.index;
+  }
+  return { value: result, index };
+}
+
+function parseArray(lines, start, indent) {
+  const result = [];
+  let index = start;
+  while (index < lines.length) {
+    const line = lines[index];
+    if (line.indent < indent) break;
+    if (line.indent > indent) throw new Error(`unexpected indentation near "${line.text}"`);
+    if (!line.text.startsWith('- ')) break;
+
+    const rest = line.text.slice(2).trim();
+    index += 1;
+    if (!rest) {
+      if (index >= lines.length || lines[index].indent <= indent) {
+        result.push(null);
+        continue;
+      }
+      const parsed = parseBlock(lines, index, lines[index].indent);
+      result.push(parsed.value);
+      index = parsed.index;
+      continue;
+    }
+
+    const pair = splitKeyValue(rest);
+    if (pair && pair[0] && !rest.startsWith('"') && !rest.startsWith("'")) {
+      const item = {};
+      item[pair[0]] = pair[1] ? parseScalar(pair[1]) : null;
+      if (index < lines.length && lines[index].indent > indent) {
+        const parsed = parseObject(lines, index, lines[index].indent);
+        Object.assign(item, parsed.value);
+        index = parsed.index;
+      }
+      result.push(item);
+    } else {
+      result.push(parseScalar(rest));
+    }
+  }
+  return { value: result, index };
+}
+
+function parseBlock(lines, start, indent) {
+  if (start >= lines.length) return { value: null, index: start };
+  if (lines[start].text.startsWith('- ')) return parseArray(lines, start, indent);
+  return parseObject(lines, start, indent);
+}
+
+function parseYaml(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return {};
+  if (trimmed.startsWith('{') || trimmed.startsWith('[')) return JSON.parse(trimmed);
+  const lines = preprocess(input);
+  if (lines.length === 0) return {};
+  return parseBlock(lines, 0, lines[0].indent).value;
+}
+
+function scalarToYaml(value) {
+  if (value === null || value === undefined) return 'null';
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  const text = String(value);
+  if (text === '' || /[:#\[\]{},]|^\s|\s$|^(true|false|null|~|-?\d+(\.\d+)?)$/.test(text)) {
+    return JSON.stringify(text);
+  }
+  return text;
+}
+
+function stringifyValue(value, indent) {
+  const pad = ' '.repeat(indent);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return '[]';
+    return value.map((item) => {
+      if (item && typeof item === 'object' && !Array.isArray(item)) {
+        const lines = stringifyObject(item, indent + 2).split('\n');
+        return `${pad}- ${lines[0].trimStart()}\n${lines.slice(1).join('\n')}`;
+      }
+      if (Array.isArray(item)) {
+        return `${pad}- ${stringifyValue(item, indent + 2).trimStart()}`;
+      }
+      return `${pad}- ${scalarToYaml(item)}`;
+    }).join('\n');
+  }
+  if (value && typeof value === 'object') {
+    return `\n${stringifyObject(value, indent)}`;
+  }
+  return scalarToYaml(value);
+}
+
+function stringifyObject(object, indent = 0) {
+  const pad = ' '.repeat(indent);
+  return Object.entries(object).map(([key, value]) => {
+    if (Array.isArray(value)) {
+      const rendered = stringifyValue(value, indent + 2);
+      return rendered === '[]' ? `${pad}${key}: []` : `${pad}${key}:\n${rendered}`;
+    }
+    if (value && typeof value === 'object') {
+      return `${pad}${key}:\n${stringifyObject(value, indent + 2)}`;
+    }
+    return `${pad}${key}: ${scalarToYaml(value)}`;
+  }).join('\n');
+}
+
+function stringifyYaml(value) {
+  if (Array.isArray(value)) return `${stringifyValue(value, 0)}\n`;
+  return `${stringifyObject(value, 0)}\n`;
+}
+
+module.exports = {
+  parseYaml,
+  stringifyYaml,
+};