@really-knows-ai/foundry 1.2.2 → 1.3.0

package/scripts/lib/config.js

@@ -0,0 +1,154 @@
+/**
+ * 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 commands = [];
+  const regex = /```(?:bash|sh)\n([\s\S]*?)```/g;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    for (const line of match[1].trim().split('\n')) {
+      const trimmed = line.trim();
+      if (trimmed) commands.push(trimmed);
+    }
+  }
+  return commands;
+}
+
+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.js

@@ -0,0 +1,285 @@
+/**
+ * Feedback parsing and manipulation utilities for WORK.md.
+ */
+
+import { extractAllTags } from './tags.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 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 (cycleFiles.has(currentFile) && /^- \[/.test(stripped)) {
+      items.push(parseFeedbackItem(stripped));
+    }
+  }
+
+  return items;
+}
+
+// ---------------------------------------------------------------------------
+// Manipulation
+// ---------------------------------------------------------------------------
+
+export function addFeedbackItem(text, file, itemText, tag) {
+  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 lines.join('\n');
+  }
+
+  // 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 lines.join('\n');
+  }
+
+  // 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 lines.join('\n');
+}
+
+export function actionFeedbackItem(text, file, index) {
+  return transformFeedbackItem(text, file, index, (line) =>
+    line.replace('- [ ]', '- [x]')
+  );
+}
+
+export function wontfixFeedbackItem(text, file, index, reason) {
+  return transformFeedbackItem(text, file, index, (line) =>
+    line.replace('- [ ]', '- [~]') + ` | wont-fix: ${reason}`
+  );
+}
+
+export function resolveFeedbackItem(text, file, index, resolution, reason) {
+  return transformFeedbackItem(text, file, index, (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 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 (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;
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+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/history.js

@@ -0,0 +1,47 @@
+import yaml from 'js-yaml';
+
+/**
+ * Load history entries for a cycle, sorted by timestamp ascending.
+ */
+export function loadHistory(historyPath, cycle, io) {
+  if (!io.exists(historyPath)) return [];
+  const data = yaml.load(io.readFile(historyPath)) || [];
+  const filtered = data.filter(e => e.cycle === cycle);
+  filtered.sort((a, b) => {
+    const ta = a.timestamp ? new Date(a.timestamp).getTime() : 0;
+    const tb = b.timestamp ? new Date(b.timestamp).getTime() : 0;
+    return ta - tb;
+  });
+  return filtered;
+}
+
+/**
+ * Append a history entry with auto-generated ISO timestamp.
+ */
+export function appendEntry(historyPath, { cycle, stage, iteration, comment }, io) {
+  if (iteration == null) throw new Error('iteration is required');
+  if (!comment) throw new Error('comment is required');
+
+  let existing = [];
+  if (io.exists(historyPath)) {
+    existing = yaml.load(io.readFile(historyPath)) || [];
+  }
+
+  existing.push({
+    cycle,
+    stage,
+    iteration,
+    comment,
+    timestamp: new Date().toISOString(),
+  });
+
+  io.writeFile(historyPath, yaml.dump(existing));
+}
+
+/**
+ * Count forge entries for a cycle.
+ */
+export function getIteration(historyPath, cycle, io) {
+  const history = loadHistory(historyPath, cycle, io);
+  return history.filter(e => (e.stage || '').split(':')[0] === 'forge').length;
+}

package/scripts/lib/workfile.js

@@ -0,0 +1,53 @@
+/**
+ * Shared WORK.md parsing and generation utilities.
+ */
+
+import yaml from 'js-yaml';
+
+// ---------------------------------------------------------------------------
+// Frontmatter parsing
+// ---------------------------------------------------------------------------
+
+export function parseFrontmatter(text) {
+  const match = text.match(/^---\n(.+?)\n---/s);
+  if (!match) return {};
+  return yaml.load(match[1]) || {};
+}
+
+export function writeFrontmatter(fields) {
+  const body = yaml.dump(fields, { lineWidth: -1 }).trimEnd();
+  return `---\n${body}\n---`;
+}
+
+export function getFrontmatterField(text, key) {
+  const fm = parseFrontmatter(text);
+  return fm[key];
+}
+
+export function setFrontmatterField(text, key, value) {
+  const fm = parseFrontmatter(text);
+  fm[key] = value;
+  const fmBlock = writeFrontmatter(fm);
+
+  // Strip existing frontmatter (if any) and prepend new one
+  const body = text.replace(/^---\n.+?\n---\n?/s, '');
+  return body ? `${fmBlock}\n${body}` : fmBlock;
+}
+
+// ---------------------------------------------------------------------------
+// Workfile creation
+// ---------------------------------------------------------------------------
+
+export function createWorkfile(frontmatter, goal) {
+  const fm = writeFrontmatter(frontmatter);
+  return `${fm}
+# Goal
+
+${goal}
+
+| Artefact | Status |
+|----------|--------|
+
+## Feedback
+`;
+}