@really-knows-ai/foundry 3.3.9 → 3.5.1

package/dist/scripts/lib/artefacts.js

@@ -1,151 +1,166 @@
 /**
- * Artefacts table utilities for WORK.md.
+ * Artefact discovery and branch change utilities.
  *
- * Parses, adds rows to, and updates status in the markdown artefacts table.
+ * Resolves the branch base SHA, collects changed files on the flow branch,
+ * filters by artefact type file-patterns, and returns the artefact change set.
  */
 
-// --- Table line classifiers ---
+import { minimatch } from 'minimatch';
+import { sortPaths } from './attestation/hash.js';
+import { getArtefactType } from './config.js';
+
+// --- Shared branch artefact discovery ---
+
+const STATUS_HANDLERS = {
+  A: (parts) => [{ file: parts[1], state: 'new' }],
+  M: (parts) => [{ file: parts[1], state: 'modified' }],
+  T: (parts) => [{ file: parts[1], state: 'modified' }],
+  U: (parts) => [{ file: parts[1], state: 'modified' }],
+  D: (parts) => [{ file: parts[1], state: 'deleted' }],
+  R: (parts) => [
+    { file: parts[1], state: 'deleted' },
+    { file: parts[2], state: 'new' },
+  ],
+  C: (parts) => [{ file: parts[2], state: 'new' }],
+};
 
-function isTableHeader(line) {
-  return line.startsWith('| File');
-}
-
-function isTableSeparator(line) {
-  return line.startsWith('|---');
-}
-
-function isTableRow(line) {
-  return line.startsWith('|');
-}
-
-function parseTableRow(line) {
-  const cols = line.split('|').slice(1, -1).map(c => c.trim());
-  return cols.length >= 4 ? cols : null;
-}
-
-// --- Status validation ---
-
-function validateStatus(newStatus) {
-  if (newStatus === 'draft') {
-    throw new Error('status draft not permitted; artefacts are registered automatically during orchestration');
-  }
-  if (!['done', 'blocked'].includes(newStatus)) {
-    throw new Error(`invalid status: ${newStatus}`);
-  }
+/**
+ * Parse a single git diff --name-status line into one or more { file, state } entries.
+ * Uses a lookup table to map status codes to handlers.
+ * @param {string} line - A line from git diff --name-status output
+ * @returns {Array<{file: string, state: string}>}
+ */
+function parseDiffStatusLine(line) {
+  const parts = line.split('\t');
+  const handler = STATUS_HANDLERS[parts[0][0]];
+  return handler ? handler(parts) : [];
 }
 
-// --- Table boundary detection ---
-
-function findTableHeader(lines) {
-  for (let i = 0; i < lines.length; i++) {
-    if (isTableHeader(lines[i].trim())) return i;
+/**
+ * Parse git diff --name-status output into an array of { file, state } entries.
+ * @param {string} output - Raw output from git diff --name-status
+ * @returns {Array<{file: string, state: string}>}
+ */
+function parseDiffOutput(output) {
+  const entries = [];
+  if (!output) return entries;
+  for (const line of output.trim().split('\n')) {
+    if (!line) continue;
+    for (const entry of parseDiffStatusLine(line)) {
+      entries.push(entry);
+    }
   }
-  return -1;
+  return entries;
 }
 
-function findTableSeparator(lines, afterIdx) {
-  for (let i = afterIdx + 1; i < lines.length; i++) {
-    if (isTableSeparator(lines[i].trim())) return i;
+/**
+ * Collect changed files from the branch since a given base SHA.
+ * Combines committed, unstaged, staged, and untracked changes.
+ *
+ * Sources are ordered by increasing priority: committed, unstaged, staged, untracked.
+ * This function does not deduplicate per-file entries; call dedupeArtefactChanges for that.
+ *
+ * @param {string} branchBaseSha - The merge-base SHA for the branch
+ * @param {object} io - IO interface with exec
+ * @returns {Array<{file: string, state: string}>}
+ */
+function getBranchChangedFiles(branchBaseSha, io) {
+  const changes = [];
+
+  // Diff-based sources: committed, unstaged, staged
+  changes.push(...parseDiffOutput(io.exec(['git', 'diff', '--name-status', `${branchBaseSha}..HEAD`])));
+  changes.push(...parseDiffOutput(io.exec(['git', 'diff', '--name-status'])));
+  changes.push(...parseDiffOutput(io.exec(['git', 'diff', '--cached', '--name-status'])));
+
+  // Untracked files (not in git)
+  const untracked = io.exec(['git', 'ls-files', '--others', '--exclude-standard']);
+  if (untracked) {
+    for (const file of untracked.trim().split('\n')) {
+      if (!file) continue;
+      changes.push({ file, state: 'new' });
+    }
   }
-  return -1;
-}
 
-function getTableBounds(lines) {
-  const headerIdx = findTableHeader(lines);
-  if (headerIdx < 0) return null;
-  const sepIdx = findTableSeparator(lines, headerIdx);
-  if (sepIdx < 0) return null;
-  return { headerIdx, sepIdx };
+  return changes;
 }
 
-function findTableEnd(lines, startIdx) {
-  for (let i = startIdx; i < lines.length; i++) {
-    const stripped = lines[i].trim();
-    if (!isTableRow(stripped)) return i;
+/**
+ * Deduplicate artefact changes, keeping the most recent state for each file.
+ * Because later git sources (staged, untracked) take precedence over earlier
+ * ones (committed), the last occurrence of a file wins.
+ *
+ * @param {Array<{file: string, state: string}>} changes
+ * @returns {Array<{file: string, state: string}>}
+ */
+function dedupeArtefactChanges(changes) {
+  const seen = new Map();
+  for (const { file, state } of changes) {
+    seen.set(file, state);
   }
-  return lines.length;
-}
-
-function formatTableRow(cols) {
-  return '| ' + cols.join(' | ') + ' |';
+  return Array.from(seen.entries()).map(([file, state]) => ({ file, state }));
 }
 
 /**
- * Parse the artefacts markdown table from text.
- * @param {string} text
- * @returns {Array<{file: string, type: string, cycle: string, status: string}>}
+ * Resolve the merge-base SHA between HEAD and a base branch.
+ * @param {object} io - IO interface with exec
+ * @param {string} [baseBranch='main'] - Base branch name
+ * @returns {string} The merge-base commit SHA
  */
-export function parseArtefactsTable(text) {
-  const lines = text.split('\n');
-  const bounds = getTableBounds(lines);
-  if (!bounds) return [];
-
-  const artefacts = [];
-  const endIdx = findTableEnd(lines, bounds.sepIdx + 1);
-
-  for (let i = bounds.sepIdx + 1; i < endIdx; i++) {
-    const cols = parseTableRow(lines[i].trim());
-    if (cols) {
-      artefacts.push({
-        file: cols[0],
-        type: cols[1],
-        cycle: cols[2],
-        status: cols[3],
-      });
-    }
+export function resolveBranchBaseSha(io, baseBranch = 'main') {
+  if (!io.exec) {
+    throw new Error('io.exec is required for resolveBranchBaseSha');
   }
-
-  return artefacts;
+  const sha = io.exec(['git', 'merge-base', 'HEAD', baseBranch]).trim();
+  if (!sha) {
+    throw new Error(`Failed to resolve merge-base for HEAD and ${baseBranch}`);
+  }
+  return sha;
 }
 
 /**
- * Add a row to the artefacts table.
- * @param {string} text - Full WORK.md text
- * @param {{file: string, type: string, cycle: string, status: string}} row
- * @returns {string} Updated text
+ * Extract file-patterns from an artefact type definition frontmatter.
+ * Returns an empty array when frontmatter is absent or contains no patterns.
+ * @param {object} def - Artefact type definition with frontmatter
+ * @returns {Array<string>}
  */
-export function addArtefactRow(text, { file, type, cycle, status }) {
-  const lines = text.split('\n');
-  const bounds = getTableBounds(lines);
-
-  if (!bounds) {
-    throw new Error('Artefacts table not found');
-  }
-
-  const endIdx = findTableEnd(lines, bounds.sepIdx + 1);
-  const insertAt = endIdx > bounds.sepIdx + 1 ? endIdx - 1 : bounds.sepIdx;
-  const newRow = `| ${file} | ${type} | ${cycle} | ${status} |`;
-  lines.splice(insertAt + 1, 0, newRow);
-  return lines.join('\n');
+function getFilePatterns(def) {
+  const fm = def.frontmatter;
+  return Array.isArray(fm && fm['file-patterns']) ? fm['file-patterns'] : [];
 }
 
 /**
- * Update the status column for a specific file in the artefacts table.
- * @param {string} text - Full WORK.md text
- * @param {string} file - File name to match
- * @param {string} newStatus - New status value
- * @returns {string} Updated text
+ * Get artefact files for a given artefact type using shared branch discovery.
+ *
+ * Reads the artefact type definition, resolves the branch base, collects changed
+ * files on the flow branch, filters by the type's file-patterns, and returns a
+ * deterministically sorted list of { file, state } entries.
+ *
+ * @param {string} foundryDir - Path to the foundry directory
+ * @param {string} typeId - Artefact type identifier
+ * @param {object} io - IO interface with exec, readFile, exists
+ * @param {object} [options={}] - Optional parameters
+ * @param {string} [options.baseBranch='main'] - Base branch for merge-base resolution
+ * @param {string} [options.branchBaseSha] - Pre-resolved merge-base SHA (takes precedence)
+ * @returns {Promise<Array<{file: string, state: string}>>}
  */
-export function setArtefactStatus(text, file, newStatus) {
-  validateStatus(newStatus);
-
-  const lines = text.split('\n');
-  const bounds = getTableBounds(lines);
-
-  if (!bounds) {
-    throw new Error(`File not found in artefacts table: ${file}`);
-  }
-
-  const endIdx = findTableEnd(lines, bounds.sepIdx + 1);
-
-  for (let i = bounds.sepIdx + 1; i < endIdx; i++) {
-    const cols = parseTableRow(lines[i].trim());
-    if (cols && cols[0] === file) {
-      cols[3] = newStatus;
-      lines[i] = formatTableRow(cols);
-      return lines.join('\n');
-    }
-  }
-
-  throw new Error(`File not found in artefacts table: ${file}`);
+export async function getArtefactFiles(foundryDir, typeId, io, options = {}) {
+  const def = await getArtefactType(foundryDir, typeId, io);
+  const patterns = getFilePatterns(def);
+
+  if (patterns.length === 0) return [];
+
+  const baseBranch = options.baseBranch || 'main';
+  const branchBaseSha = options.branchBaseSha || resolveBranchBaseSha(io, baseBranch);
+  const changedFiles = getBranchChangedFiles(branchBaseSha, io);
+  const changes = dedupeArtefactChanges(changedFiles);
+  const matching = changes.filter(({ file }) =>
+    patterns.some(pattern => minimatch(file, pattern))
+  );
+
+  // Sort deterministically by file path
+  const sorted = sortPaths(matching.map(({ file }) => file));
+  const order = new Map(sorted.map((file, idx) => [file, idx]));
+  const result = [...matching].sort((a, b) => order.get(a.file) - order.get(b.file));
+
+  return result;
 }

package/dist/scripts/lib/attestation/attest.js

@@ -7,7 +7,6 @@
 import path from 'node:path';
 import { load as loadYaml } from 'js-yaml';
 import { parseFrontmatter } from '../workfile.js';
-import { parseArtefactsTable } from '../artefacts.js';
 import { parseAllHistoryEntries } from '../history.js';
 import { sha256Buffer } from './hash.js';
 import { buildAttestationPayload } from './payload.js';
@@ -21,19 +20,11 @@ function readWorkFiles(cwd, io) {
 
   return {
     workText: io.readFile(workPath),
-    historyText: io.fileExists(historyPath) ? io.readFile(historyPath) : '',
-    feedbackText: io.fileExists(feedbackPath) ? io.readFile(feedbackPath) : '',
+    historyText: io.exists(historyPath) ? io.readFile(historyPath) : '',
+    feedbackText: io.exists(feedbackPath) ? io.readFile(feedbackPath) : '',
   };
 }
 
-function checkBlockedArtefacts(artefacts) {
-  const blocked = artefacts.filter(a => a.status === 'blocked');
-  if (blocked.length > 0) {
-    return `foundry_attest: cycle has blocked artefact(s): ${blocked.map(a => a.file).join(', ')}`;
-  }
-  return null;
-}
-
 function checkMissingStages(frontmatter, historyText) {
   const entries = parseAllHistoryEntries(historyText);
   const completed = new Set(entries.map(e => e.stage));
@@ -54,10 +45,7 @@ function checkUnresolvedFeedback(feedbackText) {
   return null;
 }
 
-function findCycleError(frontmatter, artefacts, historyText, feedbackText) {
-  const blockedError = checkBlockedArtefacts(artefacts);
-  if (blockedError) return blockedError;
-
+function findCycleError(frontmatter, historyText, feedbackText) {
   const missingError = checkMissingStages(frontmatter, historyText);
   if (missingError) return missingError;
 
@@ -73,7 +61,9 @@ function computeDiffSha(execGit, baseBranch) {
 
 export async function buildAttestation({
   cwd,
+  foundryDir,
   baseBranch,
+  branchBaseSha,
   goalText,
   archiveBranch,
   archiveTipSha,
@@ -82,20 +72,22 @@ export async function buildAttestation({
 }) {
   const { workText, historyText, feedbackText } = readWorkFiles(cwd, io);
   const frontmatter = parseFrontmatter(workText);
-  const artefacts = parseArtefactsTable(workText);
 
-  const cycleError = findCycleError(frontmatter, artefacts, historyText, feedbackText);
+  const cycleError = findCycleError(frontmatter, historyText, feedbackText);
   if (cycleError) {
     return { ok: false, error: cycleError };
   }
 
   const diffSha = computeDiffSha(execGit, baseBranch);
 
-  const payload = buildAttestationPayload({
+  const payload = await buildAttestationPayload({
     cwd,
+    foundryDir: foundryDir ?? 'foundry',
     goalText,
     archiveBranch,
     archiveTipSha,
+    baseBranch,
+    branchBaseSha,
     io,
   });
 

package/dist/scripts/lib/attestation/payload.js

@@ -5,26 +5,29 @@
  */
 
 import { readFileSync, existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
 import path from 'node:path';
 import { parseFrontmatter } from '../workfile.js';
-import { parseArtefactsTable } from '../artefacts.js';
+import { getArtefactFiles } from '../artefacts.js';
+import { getCycleDefinition } from '../config.js';
 import { parseAllHistoryEntries } from '../history.js';
 import { sha256Text, sortPaths } from './hash.js';
 
-function defaultIo() {
+function defaultIo(cwd) {
   return {
     readFile: (filePath) => readFileSync(filePath, 'utf8'),
-    fileExists: (filePath) => existsSync(filePath),
+    exists: (filePath) => existsSync(filePath),
+    exec: (args) => execFileSync(args[0], args.slice(1), { cwd, encoding: 'utf8' }),
   };
 }
 
 function readWorkFiles(cwd, io) {
-  const { readFile, fileExists } = io ?? defaultIo();
+  const { readFile, exists } = io ?? defaultIo(cwd);
 
   return {
     workText: readFile(path.join(cwd, 'WORK.md')),
-    historyText: fileExists(path.join(cwd, 'WORK.history.yaml')) ? readFile(path.join(cwd, 'WORK.history.yaml')) : '',
-    feedbackText: fileExists(path.join(cwd, 'WORK.feedback.yaml')) ? readFile(path.join(cwd, 'WORK.feedback.yaml')) : '',
+    historyText: exists(path.join(cwd, 'WORK.history.yaml')) ? readFile(path.join(cwd, 'WORK.history.yaml')) : '',
+    feedbackText: exists(path.join(cwd, 'WORK.feedback.yaml')) ? readFile(path.join(cwd, 'WORK.feedback.yaml')) : '',
   };
 }
 
@@ -85,11 +88,34 @@ function buildGovernance(frontmatter, workText, historyText, feedbackText) {
   };
 }
 
-export function buildAttestationPayload({ cwd, goalText, archiveBranch, archiveTipSha, io }) {
-  const { workText, historyText, feedbackText } = readWorkFiles(cwd, io);
+async function discoverCycleOutputs(resolvedFd, cycleId, resolvedIo, options) {
+  try {
+    const cfm = (await getCycleDefinition(resolvedFd, cycleId, resolvedIo)).frontmatter;
+    const outputType = cfm && cfm['output-type'];
+    if (outputType) return getArtefactFiles(resolvedFd, outputType, resolvedIo, options);
+  } catch {
+    // If cycle definition is missing, outputs remain empty
+  }
+  return [];
+}
+
+export async function buildAttestationPayload(
+  { cwd, foundryDir: fd, goalText, archiveBranch, archiveTipSha, baseBranch, branchBaseSha, io },
+) {
+  const resolvedIo = io || defaultIo(cwd);
+  const resolvedFd = fd || 'foundry';
+  const { workText, historyText, feedbackText } = readWorkFiles(cwd, resolvedIo);
 
   const frontmatter = parseFrontmatter(workText);
-  const artefacts = parseArtefactsTable(workText);
+
+  // Discover artefact outputs from branch changes
+  let outputs = [];
+  const cycleId = frontmatter.cycle;
+  if (cycleId) {
+    outputs = await discoverCycleOutputs(resolvedFd, cycleId, resolvedIo, { baseBranch, branchBaseSha });
+  }
+
+  const outputEntries = outputs.map(({ file, state }) => ({ path: file, state }));
 
   const sortedEntries = parseAndSortHistoryEntries(historyText);
   const stages = buildStagesFromEntries(sortedEntries);
@@ -97,7 +123,7 @@ export function buildAttestationPayload({ cwd, goalText, archiveBranch, archiveT
   return {
     contract: buildContract(frontmatter),
     governance: buildGovernance(frontmatter, workText, historyText, feedbackText),
-    outputs: artefacts.map(row => ({ path: row.file, status: row.status })),
+    outputs: outputEntries,
     process: { stages },
     request: { goal_text: goalText },
     schema: 'foundry-attestation/v1',

package/dist/scripts/lib/finalize.js

@@ -49,7 +49,7 @@ function classifyFiles(files, allowedPatterns) {
   return { matched, unexpected };
 }
 
-export function finalizeStage({ cwd, baseSha, stageBase, cycleDef, artefactTypes, registerArtefact, io }) {
+export function finalizeStage({ cwd, baseSha, stageBase, cycleDef, artefactTypes, io }) {
   if (!io?.exec) {
     throw new Error('finalizeStage: io.exec is required');
   }
@@ -62,9 +62,9 @@ export function finalizeStage({ cwd, baseSha, stageBase, cycleDef, artefactTypes
   // For non-forge stages, matched files are tool-managed side effects
   // (e.g. assay's memory writes) that should not become artefacts.
   if (stageBase !== 'forge') return { ok: true, artefacts: [], changedFiles: sortedFiles };
-  const artefacts = sortedFiles.map(file => {
-    registerArtefact({ file, type: cycleDef.outputArtefactType, status: 'draft' });
-    return { file, type: cycleDef.outputArtefactType, status: 'draft' };
-  });
+  const artefacts = sortedFiles.map(file => ({
+    file,
+    type: cycleDef.outputArtefactType,
+  }));
   return { ok: true, artefacts, changedFiles: sortedFiles };
 }