@really-knows-ai/foundry 2.3.1 → 3.0.0

package/scripts/lib/config.js

@@ -1,175 +0,0 @@
-/**
- * Structured reads of foundry/ directory contents.
- */
-
-import { join } from 'path';
-import { parseFrontmatter } from './workfile.js';
-
-function parseDoc(text) {
-  const frontmatter = parseFrontmatter(text);
-  const body = text.replace(/^---\n.+?\n---\n?/s, '').trim();
-  return { frontmatter, body };
-}
-
-export async function getCycleDefinition(foundryDir, cycleId, io) {
-  const path = join(foundryDir, 'cycles', `${cycleId}.md`);
-  if (!(await io.exists(path))) {
-    throw new Error(`Cycle not found: ${cycleId}`);
-  }
-  const text = await io.readFile(path);
-  return parseDoc(text);
-}
-
-export async function getArtefactType(foundryDir, typeId, io) {
-  const path = join(foundryDir, 'artefacts', typeId, 'definition.md');
-  if (!(await io.exists(path))) {
-    throw new Error(`Artefact type not found: ${typeId}`);
-  }
-  const text = await io.readFile(path);
-  return parseDoc(text);
-}
-
-export async function getLaws(foundryDir, typeId, io) {
-  // Handle optional typeId: if typeId is the io object, shift args
-  if (typeId && typeof typeId === 'object' && typeof typeId.exists === 'function') {
-    io = typeId;
-    typeId = null;
-  }
-
-  const laws = [];
-
-  function parseLaws(text, source) {
-    const lines = text.split('\n');
-    let currentId = null;
-    let currentLines = [];
-
-    for (const line of lines) {
-      const heading = line.match(/^## (.+)/);
-      if (heading) {
-        if (currentId) {
-          laws.push({ id: currentId, text: currentLines.join('\n').trim(), source });
-        }
-        currentId = heading[1];
-        currentLines = [];
-      } else if (currentId) {
-        currentLines.push(line);
-      }
-    }
-    if (currentId) {
-      laws.push({ id: currentId, text: currentLines.join('\n').trim(), source });
-    }
-  }
-
-  // Global laws
-  const globalDir = join(foundryDir, 'laws');
-  if (await io.exists(globalDir)) {
-    const files = await io.readDir(globalDir);
-    const mdFiles = files.filter(f => f.endsWith('.md')).sort();
-    for (const file of mdFiles) {
-      const text = await io.readFile(join(globalDir, file));
-      parseLaws(text, `laws/${file}`);
-    }
-  }
-
-  // Type-specific laws
-  if (typeId) {
-    const typeLawsPath = join(foundryDir, 'artefacts', typeId, 'laws.md');
-    if (await io.exists(typeLawsPath)) {
-      const text = await io.readFile(typeLawsPath);
-      parseLaws(text, `artefacts/${typeId}/laws.md`);
-    }
-  }
-
-  return laws;
-}
-
-export async function getValidation(foundryDir, typeId, io) {
-  const path = join(foundryDir, 'artefacts', typeId, 'validation.md');
-  if (!(await io.exists(path))) {
-    return null;
-  }
-  const text = await io.readFile(path);
-  const entries = [];
-  const lines = text.split('\n');
-  let currentId = null;
-  let currentCommand = null;
-  let currentFailure = null;
-
-  function flush() {
-    if (currentId && currentCommand) {
-      const entry = { id: currentId, command: currentCommand };
-      if (currentFailure) entry.failureMeans = currentFailure;
-      entries.push(entry);
-    }
-    currentId = null;
-    currentCommand = null;
-    currentFailure = null;
-  }
-
-  for (const line of lines) {
-    const heading = line.match(/^## (.+)/);
-    if (heading) {
-      flush();
-      currentId = heading[1].trim();
-    } else if (currentId) {
-      const cmdMatch = line.match(/^Command:\s*(.+)/);
-      const failMatch = line.match(/^Failure means:\s*(.+)/);
-      if (cmdMatch) currentCommand = cmdMatch[1].trim().replace(/^`|`$/g, '');
-      if (failMatch) currentFailure = failMatch[1].trim();
-    }
-  }
-  flush();
-  return entries;
-}
-
-export async function getAppraisers(foundryDir, io) {
-  const dir = join(foundryDir, 'appraisers');
-  if (!(await io.exists(dir))) return [];
-  const files = await io.readDir(dir);
-  const mdFiles = files.filter(f => f.endsWith('.md')).sort();
-  const result = [];
-  for (const file of mdFiles) {
-    const text = await io.readFile(join(dir, file));
-    const { frontmatter, body } = parseDoc(text);
-    const entry = { id: frontmatter.id, personality: body };
-    if (frontmatter.model) entry.model = frontmatter.model;
-    result.push(entry);
-  }
-  return result;
-}
-
-export async function getFlow(foundryDir, flowId, io) {
-  const path = join(foundryDir, 'flows', `${flowId}.md`);
-  if (!(await io.exists(path))) {
-    throw new Error(`Flow not found: ${flowId}`);
-  }
-  const text = await io.readFile(path);
-  return parseDoc(text);
-}
-
-export async function selectAppraisers(foundryDir, typeId, countOverride, io) {
-  // Handle optional countOverride
-  if (countOverride && typeof countOverride === 'object' && typeof countOverride.exists === 'function') {
-    io = countOverride;
-    countOverride = null;
-  }
-
-  const { frontmatter } = await getArtefactType(foundryDir, typeId, io);
-  const appraiserConfig = frontmatter.appraisers || {};
-  const count = countOverride || appraiserConfig.count || 3;
-  const allowed = appraiserConfig.allowed || null;
-
-  const allAppraisers = await getAppraisers(foundryDir, io);
-  let pool = allowed
-    ? allAppraisers.filter(a => allowed.includes(a.id))
-    : allAppraisers;
-
-  if (pool.length === 0) return [];
-
-  // Round-robin distribute
-  const result = [];
-  for (let i = 0; i < count; i++) {
-    result.push(pool[i % pool.length]);
-  }
-  return result;
-}

package/scripts/lib/feedback-transitions.js

@@ -1,25 +0,0 @@
-import { createHash } from 'node:crypto';
-
-// Matrix: [current][target] => set of allowed stageBases
-const MATRIX = {
-  open:       { actioned: ['forge'], 'wont-fix': ['forge'] },
-  actioned:   { approved: ['quench', 'appraise', 'human-appraise'], rejected: ['quench', 'appraise', 'human-appraise'] },
-  'wont-fix': { approved: ['appraise', 'human-appraise'], rejected: ['appraise', 'human-appraise'] },
-  rejected:   { actioned: ['forge'], 'wont-fix': ['forge'] },
-  approved:   {}, // terminal
-};
-
-export function validateTransition(current, target, stageBase) {
-  const row = MATRIX[current];
-  if (!row) return { ok: false, reason: `unknown state: ${current}` };
-  const allowedStages = row[target];
-  if (!allowedStages) return { ok: false, reason: `invalid transition ${current} → ${target}` };
-  if (!allowedStages.includes(stageBase)) {
-    return { ok: false, reason: `stage ${stageBase} cannot transition ${current} → ${target}` };
-  }
-  return { ok: true };
-}
-
-export function hashText(text) {
-  return createHash('sha256').update(text).digest('hex').slice(0, 16);
-}

package/scripts/lib/feedback.js

@@ -1,440 +0,0 @@
-/**
- * Feedback parsing and manipulation utilities for WORK.md.
- */
-
-import { extractAllTags } from './tags.js';
-import { validateTransition, hashText } from './feedback-transitions.js';
-
-// ---------------------------------------------------------------------------
-// Parsing
-// ---------------------------------------------------------------------------
-
-export function parseFeedbackItem(line) {
-  const item = { raw: line, state: 'unknown', tags: [], resolved: false };
-
-  if (line.startsWith('- [ ]')) {
-    item.state = 'open';
-  } else if (line.startsWith('- [x]')) {
-    item.state = 'actioned';
-  } else if (line.startsWith('- [~]')) {
-    item.state = 'wont-fix';
-  }
-
-  if (line.includes('| approved')) {
-    item.resolved = true;
-  } else if (line.includes('| rejected')) {
-    item.state = 'rejected';
-    item.resolved = false;
-  }
-
-  item.tags = extractAllTags(line);
-
-  return item;
-}
-
-export function parseFeedback(text, cycle, artefacts) {
-  const cycleFiles = new Set();
-  for (const art of artefacts) {
-    if (art.cycle === cycle) {
-      cycleFiles.add(art.file || '');
-    }
-  }
-  const filterByFile = cycleFiles.size > 0;
-
-  const items = [];
-  let currentFile = null;
-  let inFeedback = false;
-  let feedbackLevel = 0;
-
-  for (const line of text.split('\n')) {
-    const stripped = line.trim();
-
-    if (stripped === '# Feedback' || stripped === '## Feedback') {
-      inFeedback = true;
-      feedbackLevel = stripped.startsWith('## ') ? 2 : 1;
-      continue;
-    }
-
-    // Exit feedback on a heading at the same or higher level
-    if (inFeedback && /^#{1,2} /.test(stripped)) {
-      const level = stripped.startsWith('## ') ? 2 : 1;
-      if (level <= feedbackLevel && stripped !== '# Feedback' && stripped !== '## Feedback') {
-        inFeedback = false;
-        continue;
-      }
-    }
-
-    if (!inFeedback) continue;
-
-    // File sub-headings are one level below the Feedback heading
-    const fileHeadingPrefix = feedbackLevel === 1 ? '## ' : '### ';
-    if (stripped.startsWith(fileHeadingPrefix)) {
-      currentFile = stripped.slice(fileHeadingPrefix.length).trim();
-      continue;
-    }
-
-    if ((!filterByFile || cycleFiles.has(currentFile)) && /^- \[/.test(stripped)) {
-      items.push(parseFeedbackItem(stripped));
-    }
-  }
-
-  return items;
-}
-
-// ---------------------------------------------------------------------------
-// Manipulation
-// ---------------------------------------------------------------------------
-
-export function addFeedbackItem(text, file, itemText, tag) {
-  // Dedup by (file, tag, text hash): if any existing item under this file
-  // heading has the same tag and the same itemText, return without mutating.
-  const existing = collectItemsForFile(text, file);
-  const h = hashText(itemText);
-  for (const ex of existing) {
-    if (ex.tags.includes(`#${tag}`) && hashText(ex.coreText) === h) {
-      return { text, deduped: true };
-    }
-  }
-
-  const newItem = `- [ ] ${itemText} #${tag}`;
-  const lines = text.split('\n');
-
-  // Find ## Feedback section
-  let feedbackIdx = -1;
-  let feedbackLevel = 0;
-  for (let i = 0; i < lines.length; i++) {
-    const stripped = lines[i].trim();
-    if (stripped === '## Feedback') {
-      feedbackIdx = i;
-      feedbackLevel = 2;
-      break;
-    }
-    if (stripped === '# Feedback') {
-      feedbackIdx = i;
-      feedbackLevel = 1;
-      break;
-    }
-  }
-
-  const fileHeadingPrefix = feedbackLevel === 1 ? '## ' : '### ';
-  const fileHeading = `${fileHeadingPrefix}${file}`;
-
-  if (feedbackIdx === -1) {
-    // No Feedback section — append one
-    lines.push('', '## Feedback', '', `### ${file}`, newItem);
-    return { text: lines.join('\n'), deduped: false };
-  }
-
-  // Find the file heading within the feedback section
-  let fileIdx = -1;
-  let sectionEnd = lines.length; // end of feedback section
-  for (let i = feedbackIdx + 1; i < lines.length; i++) {
-    const stripped = lines[i].trim();
-    // Check if we've left the feedback section
-    if (/^#{1,2} /.test(stripped)) {
-      const level = stripped.startsWith('## ') ? 2 : 1;
-      if (level <= feedbackLevel && stripped !== '# Feedback' && stripped !== '## Feedback') {
-        sectionEnd = i;
-        break;
-      }
-    }
-    if (stripped === fileHeading.trim()) {
-      fileIdx = i;
-    }
-  }
-
-  if (fileIdx === -1) {
-    // File heading doesn't exist — add it before section end
-    lines.splice(sectionEnd, 0, '', fileHeading, newItem);
-    return { text: lines.join('\n'), deduped: false };
-  }
-
-  // Find last item under this file heading
-  let insertIdx = fileIdx + 1;
-  for (let i = fileIdx + 1; i < sectionEnd; i++) {
-    const stripped = lines[i].trim();
-    if (stripped.startsWith(fileHeadingPrefix)) break; // next file heading
-    if (/^- \[/.test(stripped)) {
-      insertIdx = i + 1;
-    }
-  }
-
-  lines.splice(insertIdx, 0, newItem);
-  return { text: lines.join('\n'), deduped: false };
-}
-
-export function actionFeedbackItem(text, file, index, stageBase) {
-  return transformFeedbackItemWithValidation(text, file, index, 'actioned', stageBase, (line) =>
-    line.replace('- [ ]', '- [x]')
-  );
-}
-
-export function wontfixFeedbackItem(text, file, index, reason, stageBase) {
-  return transformFeedbackItemWithValidation(text, file, index, 'wont-fix', stageBase, (line) =>
-    line.replace('- [ ]', '- [~]') + ` | wont-fix: ${reason}`
-  );
-}
-
-export function resolveFeedbackItem(text, file, index, resolution, reason, stageBase) {
-  return transformFeedbackItemWithValidation(text, file, index, resolution, stageBase, (line) => {
-    if (resolution === 'approved') {
-      return line + ' | approved';
-    }
-    return line + ` | rejected: ${reason}`;
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Listing
-// ---------------------------------------------------------------------------
-
-export function listFeedback(text, cycle, artefacts, filterFile) {
-  const cycleFiles = new Set();
-  for (const art of artefacts) {
-    if (art.cycle === cycle) {
-      cycleFiles.add(art.file || '');
-    }
-  }
-  const filterByCycle = cycleFiles.size > 0;
-
-  const results = [];
-  let currentFile = null;
-  let fileIndex = 0;
-  let inFeedback = false;
-  let feedbackLevel = 0;
-
-  for (const line of text.split('\n')) {
-    const stripped = line.trim();
-
-    if (stripped === '# Feedback' || stripped === '## Feedback') {
-      inFeedback = true;
-      feedbackLevel = stripped.startsWith('## ') ? 2 : 1;
-      continue;
-    }
-
-    if (inFeedback && /^#{1,2} /.test(stripped)) {
-      const level = stripped.startsWith('## ') ? 2 : 1;
-      if (level <= feedbackLevel && stripped !== '# Feedback' && stripped !== '## Feedback') {
-        inFeedback = false;
-        continue;
-      }
-    }
-
-    if (!inFeedback) continue;
-
-    const fileHeadingPrefix = feedbackLevel === 1 ? '## ' : '### ';
-    if (stripped.startsWith(fileHeadingPrefix)) {
-      currentFile = stripped.slice(fileHeadingPrefix.length).trim();
-      fileIndex = 0;
-      continue;
-    }
-
-    if ((!filterByCycle || cycleFiles.has(currentFile)) && /^- \[/.test(stripped)) {
-      if (!filterFile || filterFile === currentFile) {
-        const item = parseFeedbackItem(stripped);
-        results.push({
-          file: currentFile,
-          index: fileIndex,
-          text: item.raw,
-          state: item.state,
-          tags: item.tags,
-          resolved: item.resolved,
-        });
-      }
-      fileIndex++;
-    }
-  }
-
-  return results;
-}
-
-/**
- * Detect feedback items stuck in a deadlock — rejected N or more times.
- * A deadlock occurs when forge-appraise cycles keep rejecting the same item.
- */
-export function detectDeadlocks(feedback, history, threshold = 3) {
-  // Count forge→appraise cycles (each pair = one iteration)
-  const forgeAppraiseCount = history.filter(
-    e => (e.stage || '').split(':')[0] === 'appraise'
-  ).length;
-
-  if (forgeAppraiseCount < threshold) return [];
-
-  // Items that are still rejected after threshold iterations are deadlocked
-  return feedback.filter(f => f.state === 'rejected' || f.state === 'open');
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Collect feedback items under a specific file heading, returning the parsed
- * representation plus the "core text" (item body with tag and trailing resolution
- * stripped) for dedup hashing.
- */
-function collectItemsForFile(text, file) {
-  const items = [];
-  const lines = text.split('\n');
-  let inFeedback = false;
-  let feedbackLevel = 0;
-  let currentFile = null;
-
-  for (const line of lines) {
-    const stripped = line.trim();
-
-    if (stripped === '# Feedback' || stripped === '## Feedback') {
-      inFeedback = true;
-      feedbackLevel = stripped.startsWith('## ') ? 2 : 1;
-      continue;
-    }
-
-    if (inFeedback && /^#{1,2} /.test(stripped)) {
-      const level = stripped.startsWith('## ') ? 2 : 1;
-      if (level <= feedbackLevel && stripped !== '# Feedback' && stripped !== '## Feedback') {
-        inFeedback = false;
-        continue;
-      }
-    }
-
-    if (!inFeedback) continue;
-
-    const fileHeadingPrefix = feedbackLevel === 1 ? '## ' : '### ';
-    if (stripped.startsWith(fileHeadingPrefix)) {
-      currentFile = stripped.slice(fileHeadingPrefix.length).trim();
-      continue;
-    }
-
-    if (currentFile === file && /^- \[/.test(stripped)) {
-      const parsed = parseFeedbackItem(stripped);
-      // Strip checkbox, tags, and trailing `| approved` / `| rejected: ...` /
-      // `| wont-fix: ...` to get the core author-supplied text for dedup.
-      let core = stripped.replace(/^- \[[ x~]\]\s*/, '');
-      core = core.replace(/\s*\|\s*(approved|rejected[^|]*|wont-fix[^|]*)\s*$/, '');
-      for (const t of parsed.tags) {
-        core = core.replace(t, '');
-      }
-      core = core.trim();
-      items.push({ line: stripped, state: parsed.state, tags: parsed.tags, coreText: core });
-    }
-  }
-
-  return items;
-}
-
-/**
- * Read the line at (file, index) and return its current feedback state
- * (or null if not found).
- */
-function readItemState(text, file, index) {
-  const lines = text.split('\n');
-  let inFeedback = false;
-  let feedbackLevel = 0;
-  let currentFile = null;
-  let fileIndex = 0;
-
-  for (let i = 0; i < lines.length; i++) {
-    const stripped = lines[i].trim();
-
-    if (stripped === '# Feedback' || stripped === '## Feedback') {
-      inFeedback = true;
-      feedbackLevel = stripped.startsWith('## ') ? 2 : 1;
-      continue;
-    }
-
-    if (inFeedback && /^#{1,2} /.test(stripped)) {
-      const level = stripped.startsWith('## ') ? 2 : 1;
-      if (level <= feedbackLevel && stripped !== '# Feedback' && stripped !== '## Feedback') {
-        inFeedback = false;
-        continue;
-      }
-    }
-
-    if (!inFeedback) continue;
-
-    const fileHeadingPrefix = feedbackLevel === 1 ? '## ' : '### ';
-    if (stripped.startsWith(fileHeadingPrefix)) {
-      currentFile = stripped.slice(fileHeadingPrefix.length).trim();
-      fileIndex = 0;
-      continue;
-    }
-
-    if (currentFile === file && /^- \[/.test(stripped)) {
-      if (fileIndex === index) {
-        const parsed = parseFeedbackItem(stripped);
-        // Map parseFeedbackItem's (state, resolved) pair onto state-machine states:
-        // - `| approved` → terminal "approved"
-        // - `| rejected` → "rejected" (parseFeedbackItem already sets this)
-        // - bare `[x]`   → "actioned"
-        // - bare `[~]`   → "wont-fix"
-        // - bare `[ ]`   → "open"
-        if (parsed.resolved) return 'approved';
-        return parsed.state;
-      }
-      fileIndex++;
-    }
-  }
-  return null;
-}
-
-function transformFeedbackItemWithValidation(text, file, index, target, stageBase, transform) {
-  if (stageBase !== undefined) {
-    const current = readItemState(text, file, index);
-    if (!current) {
-      return { ok: false, error: `feedback item not found: file=${file} index=${index}` };
-    }
-    const v = validateTransition(current, target, stageBase);
-    if (!v.ok) {
-      return { ok: false, error: v.reason };
-    }
-    const updated = transformFeedbackItem(text, file, index, transform);
-    return { ok: true, text: updated };
-  }
-  // Backward-compatible path: return plain string.
-  return transformFeedbackItem(text, file, index, transform);
-}
-
-function transformFeedbackItem(text, file, index, transform) {
-  const lines = text.split('\n');
-  let inFeedback = false;
-  let feedbackLevel = 0;
-  let currentFile = null;
-  let fileIndex = 0;
-
-  for (let i = 0; i < lines.length; i++) {
-    const stripped = lines[i].trim();
-
-    if (stripped === '# Feedback' || stripped === '## Feedback') {
-      inFeedback = true;
-      feedbackLevel = stripped.startsWith('## ') ? 2 : 1;
-      continue;
-    }
-
-    if (inFeedback && /^#{1,2} /.test(stripped)) {
-      const level = stripped.startsWith('## ') ? 2 : 1;
-      if (level <= feedbackLevel && stripped !== '# Feedback' && stripped !== '## Feedback') {
-        inFeedback = false;
-        continue;
-      }
-    }
-
-    if (!inFeedback) continue;
-
-    const fileHeadingPrefix = feedbackLevel === 1 ? '## ' : '### ';
-    if (stripped.startsWith(fileHeadingPrefix)) {
-      currentFile = stripped.slice(fileHeadingPrefix.length).trim();
-      fileIndex = 0;
-      continue;
-    }
-
-    if (currentFile === file && /^- \[/.test(stripped)) {
-      if (fileIndex === index) {
-        lines[i] = transform(lines[i]);
-        return lines.join('\n');
-      }
-      fileIndex++;
-    }
-  }
-
-  return text;
-}

package/scripts/lib/finalize.js

@@ -1,41 +0,0 @@
-// scripts/lib/finalize.js
-import { execSync } from 'node:child_process';
-import { minimatch } from 'minimatch';
-
-const TOOL_MANAGED = [
-  'WORK.md',
-  'WORK.history.yaml',
-];
-const TOOL_MANAGED_PREFIX = ['.foundry/'];
-
-function changedFiles(cwd, baseSha) {
-  const tracked = execSync(`git diff --name-only ${baseSha} HEAD`, { cwd }).toString().split('\n').filter(Boolean);
-  const diffUnstaged = execSync('git diff --name-only', { cwd }).toString().split('\n').filter(Boolean);
-  const untracked = execSync('git ls-files --others --exclude-standard', { cwd }).toString().split('\n').filter(Boolean);
-  return [...new Set([...tracked, ...diffUnstaged, ...untracked])];
-}
-
-function isToolManaged(f) {
-  if (TOOL_MANAGED.includes(f)) return true;
-  return TOOL_MANAGED_PREFIX.some(p => f.startsWith(p));
-}
-
-export function finalizeStage({ cwd, baseSha, stageBase, cycleDef, artefactTypes, registerArtefact }) {
-  const files = changedFiles(cwd, baseSha).filter(f => !isToolManaged(f));
-  const allowedPatterns = stageBase === 'forge'
-    ? (artefactTypes[cycleDef.outputArtefactType]?.filePatterns ?? [])
-    : [];
-  const unexpected = [];
-  const matched = [];
-  for (const f of files) {
-    const hit = allowedPatterns.find(p => minimatch(f, p));
-    if (hit) matched.push(f);
-    else unexpected.push(f);
-  }
-  if (unexpected.length) return { ok: false, error: 'unexpected_files', files: unexpected };
-  const artefacts = matched.map(file => {
-    registerArtefact({ file, type: cycleDef.outputArtefactType, status: 'draft' });
-    return { file, type: cycleDef.outputArtefactType, status: 'draft' };
-  });
-  return { ok: true, artefacts };
-}