gcf-aif-ext 0.8.0 → 0.10.0

package/commands/gcf.js

@@ -1106,12 +1106,18 @@ function registerBoard(gcf) {
       const tag = (i) =>
         `${i.id}${i.plan?.tasks !== undefined ? ` ${i.plan.done}/${i.plan.tasks}` : ''}` +
         `${i.running ? ' (running)' : ''}${i.verified ? ' (verified)' : ''}`;
-      const byId = new Map(r.items.map((i) => [i.id, i]));
       out(o.json, r, (x) =>
         [
           `phase: ${x.phase.phase ?? x.phase.error}`,
-          ...Object.entries(x.columns).map(
-            ([s, ids]) => `${s}: ${ids.map((id) => tag(byId.get(id))).join(', ') || '-'}`,
+          // Items come in run order, so each column lists its own in that order.
+          ...x.domain.columns.map(
+            ({ status }) =>
+              `${status}: ${
+                x.items
+                  .filter((i) => i.status === status)
+                  .map(tag)
+                  .join(', ') || '-'
+              }`,
           ),
           `wip: ${x.wip.count}/${x.wip.limit}`,
           `inbox: ${x.inbox.length}, open questions: ${x.questions.length}`,
@@ -1124,14 +1130,14 @@ function registerBoard(gcf) {
 function registerSettings(gcf) {
   const config = gcf
     .command('config')
-    .description("The human's settings of gcf/config.yml: list them, or set one (commit)")
+    .description("The human's settings and the agents' language: list them, or set one (commit)")
     // A misspelt subcommand would read as a stray word and list the settings, as if set.
     .allowExcessArguments(false)
     .option('--json', 'machine output')
     .action(async (o) => {
-      const { gcfRoot, readConfig, readRawConfig } = await lib('gcf-paths');
+      const { gcfRoot, readConfig } = await lib('gcf-paths');
       await readConfig(gcfRoot()); // a config the rules refuse says so here
-      const list = (await lib('config-set')).settingsOf(await readRawConfig(gcfRoot()));
+      const list = await (await lib('config-set')).projectSettings(process.cwd());
       out(o.json, list, (x) =>
         x.map((s) => `${s.key}: ${s.value ?? '-'}  # ${s.label}`).join('\n'),
       );
@@ -1151,7 +1157,11 @@ function registerSettings(gcf) {
         commit: o.commit,
       });
       const now = `${r.key}: ${r.value ?? 'default'}`;
-      console.log(r.unchanged ? `${now} (unchanged)` : `${now}${shortHash(r.hash)}`);
+      // An ignored file is written but not committed: a worktree's agent does not read it.
+      const note = r.ignored
+        ? ' (git ignores the file: not committed, and agents in a worktree will not see it)'
+        : '';
+      console.log(r.unchanged ? `${now} (unchanged)` : `${now}${shortHash(r.hash)}${note}`);
     });
   const many = (v, prev = []) => [...prev, v];
   gcf

package/extension.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/lee-to/ai-factory/2.x/schemas/extension.schema.json",
   "name": "gcf-aif-ext",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Game Context Framework for AI Factory",
   "skills": [
     "skills/gcf-init",

package/lib/aif-config.js

@@ -1,22 +1,40 @@
 // The language AI Factory sets in `.ai-factory/config.yaml` for what an agent writes to the
 // human: `language.ui`. GCF adds no setting of its own (Methodology §5.2.3); agents read the
-// file themselves, the core reads it only for the prompts it writes.
+// file themselves, the core reads it for the prompts it writes and sets it for the board
+// (`gcf config set language.ui`).
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import YAML from 'yaml';
 
+/** AI Factory's config file, project-relative. */
+export const AIF_CONFIG = '.ai-factory/config.yaml';
+
+// A language name or code, one word in any script: anything else would break the prompt line it
+// goes in.
+export const LANGUAGE_RE = /^[\p{L}\p{N}_-]{2,32}$/u;
+
 /**
- * The project's `language.ui`, `en` by default. A missing or unreadable file gives `en`: the
- * language is a preference, and a broken one must not stop the work.
+ * `.ai-factory/config.yaml` as the file has it: `{}` when it is missing, unreadable or not a
+ * map. The language is a preference, and a broken file must not stop the work.
+ * @returns {Promise<Record<string, any>>}
  */
-export async function uiLanguage(projectDir) {
+export async function readAifConfig(projectDir) {
   try {
-    const file = path.join(path.resolve(projectDir), '.ai-factory', 'config.yaml');
-    const ui = YAML.parse(await readFile(file, 'utf8'))?.language?.ui;
+    const raw = YAML.parse(await readFile(path.join(path.resolve(projectDir), AIF_CONFIG), 'utf8'));
 
-    // A language name or code, one word: anything else would break the prompt line it goes in.
-    return typeof ui === 'string' && /^[\w-]{2,32}$/.test(ui.trim()) ? ui.trim() : 'en';
+    return raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
   } catch {
-    return 'en';
+    return {};
   }
 }
+
+/** A language of the parsed file (`ui`, `artifacts`), or null when it holds no language. */
+export function languageIn(aif, key) {
+  const v = aif?.language?.[key];
+
+  return typeof v === 'string' && LANGUAGE_RE.test(v.trim()) ? v.trim() : null;
+}
+
+/** The project's `language.ui`, `en` by default or when the value is no language. */
+export const uiLanguage = async (projectDir) =>
+  languageIn(await readAifConfig(projectDir), 'ui') ?? 'en';

package/lib/board.js

@@ -5,7 +5,7 @@ import { readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { buildLedger } from './ledger.js';
-import { readConfig, readRawConfig } from './gcf-paths.js';
+import { readConfig } from './gcf-paths.js';
 import { readLive } from './live.js';
 import { listInbox } from './inbox.js';
 import { phaseStatus } from './phase.js';
@@ -15,17 +15,16 @@ import { wipOf } from './audit-core.js';
 import { runHolder } from './main-lock.js';
 import { ITEM_TYPES } from './validate-item.js';
 import { movesOf } from './transitions.js';
+import { domainOf, hasHarness, RUNS_FROM } from './domain.js';
 import { openDepends } from './work-ops.js';
 import { listQuestions } from './questions.js';
 import { sessionActive } from './session-mark.js';
 import { agentOf } from './agent-permissions.js';
-import { settingsOf } from './config-set.js';
+import { projectSettings } from './config-set.js';
 
 // The version of the JSON below (Methodology §11): a board refuses one it does not know. Bump it
 // when a field changes meaning or goes away; a new field does not bump it.
-export const BOARD_SCHEMA = 1;
-
-const COLUMNS = ['ready', 'blocked', 'awaiting-verdict', 'awaiting-decision', 'unplayed', 'parked'];
+export const BOARD_SCHEMA = 3;
 
 /**
  * Plan progress `{tasks, done}` from its checkboxes and the plan's project path, both null
@@ -232,8 +231,19 @@ function runningKind(projectDir, id) {
   return sessionActive(projectDir, id) ? 'session' : null;
 }
 
+/**
+ * What a board may offer (§4.1): nothing while a run drives the item; with the harness, the
+ * agent's run to an item that waits for one and has no green verify yet.
+ */
+function offered(c, { running, verified, harness }) {
+  if (running) return [];
+  const runs = harness && c.data.status === RUNS_FROM && !verified;
+
+  return [...(runs ? ['run'] : []), ...movesOf(c.data)];
+}
+
 /** One item of the board. */
-async function itemOf(projectDir, c, verified, ledger) {
+async function itemOf(projectDir, c, { verified, ledger, harness }) {
   const id = String(c.data.id);
   // A trailer counts only while the item waits on main for its integrate.
   const ready = c.data.status === 'ready' && verified.has(id);
@@ -265,11 +275,13 @@ async function itemOf(projectDir, c, verified, ledger) {
     resumable,
     resume,
     verified: ready,
-    // The dependencies the run gate would refuse a ready item on now (Board-PRD §5.2).
+    // The dependencies the run gate would refuse a ready item on now (Board-PRD §5.2); none
+    // while it runs, past the gate.
     waits_for:
-      c.data.status === 'ready' ? openDepends(ledger, c.data.depends ?? [], { waiting: true }) : [],
-    // What a board may offer (§4.1): nothing while a run drives the item.
-    moves: running ? [] : movesOf(c.data),
+      c.data.status === 'ready' && !running
+        ? openDepends(ledger, c.data.depends ?? [], { waiting: true })
+        : [],
+    moves: offered(c, { running, verified: ready, harness }),
     file: `gcf/work/${c.name}`,
     log: logOf(projectDir, id),
     // Filled by board() from the inbox.
@@ -282,8 +294,11 @@ export async function board(projectDir) {
   const root = path.join(path.resolve(projectDir), 'gcf');
   const ledger = await buildLedger(projectDir);
   const verified = verifiedOf(projectDir);
+  const extensions = await extensionsOf(projectDir);
+  const harness = hasHarness(extensions);
   const items = [];
-  for (const c of ledger.items) items.push(await itemOf(projectDir, c, verified, ledger));
+  for (const c of ledger.items)
+    items.push(await itemOf(projectDir, c, { verified, ledger, harness }));
   inRunOrder(items);
   // When the wait began: the time of the commit `since` names (Board-PRD §13).
   const times = commitTimes(
@@ -306,20 +321,20 @@ export async function board(projectDir) {
     run_mode: config.run_mode,
     // What the harness hands its agent runs (Harness-PRD §7): deny rules and the context limits.
     agent: agentOf(config),
-    // The human's settings of config.yml, each with its value and default (`gcf config set`).
-    settings: settingsOf(await readRawConfig(root)),
+    // The human's settings of config.yml and the agents' language, each with its value and
+    // default (`gcf config set`).
+    settings: await projectSettings(projectDir),
     context: {
       handoff_pct: config.context_handoff_pct,
       window: config.context_window,
       compact_pct: config.auto_compact_pct,
     },
     phase: await phaseOf(projectDir),
-    extensions: await extensionsOf(projectDir),
+    extensions,
     // A malformed block reads with fields missing (live check names it): null, not absent.
     release: releaseOf(live.release),
-    columns: Object.fromEntries(
-      COLUMNS.map((s) => [s, items.filter((i) => i.status === s).map((i) => i.id)]),
-    ),
+    // The domain as data (Board-PRD decision 16): its columns, blocks, fields, moves and terms.
+    domain: domainOf(extensions),
     items,
     wip: wipOf(ledger.items, config),
     inbox,

package/lib/config-set.js

@@ -1,25 +1,36 @@
 // `gcf config set` (GCF-PRD §12.4): the human's settings of gcf/config.yml, one key at a time,
 // so a board edits them through the core and never writes the file itself. A change is checked
 // by the same rules a read applies before it is written; the rest of the file keeps its keys
-// and comments. `phases:` and `agent:` have their own commands and are not set here.
+// and comments. `phases:` and `agent:` have their own commands and are not set here. The
+// language agents write in is AI Factory's (`.ai-factory/config.yaml`), set here for the board
+// too, since AI Factory has no command for it (Board-PRD decision 12).
 import { readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import YAML from 'yaml';
 import { commitMove } from './unit-ops.js';
+import { withMainLock } from './main-lock.js';
 import { atomicWrite } from './safe-path.js';
-import { configOf, DEFAULT_CONFIG, gcfRoot, RUN_MODES } from './gcf-paths.js';
+import { configOf, DEFAULT_CONFIG, gcfRoot, readRawConfig, RUN_MODES } from './gcf-paths.js';
+import { AIF_CONFIG, LANGUAGE_RE, languageIn, readAifConfig } from './aif-config.js';
 
-/** @typedef {'number' | 'share' | 'mode' | 'command'} Kind */
+/** @typedef {'number' | 'share' | 'mode' | 'command' | 'language'} Kind */
 
 // Thrown inside the move to leave without a write or a commit.
 const NO_CHANGE = new Error('no change');
 
-/** gcf/config.yml as a YAML document with a map on top: an edit keeps its comments. */
-export function configDoc(text) {
+// The languages AI Factory's own setup offers; any other name or code is taken too.
+const LANGUAGES = ['en', 'ru', 'de', 'fr', 'es', 'zh', 'ja', 'ko', 'pt', 'it'];
+
+/** A YAML file as a document with a map on top: an edit keeps its comments. */
+export function configDoc(text, name = 'gcf/config.yml') {
   const doc = YAML.parseDocument(text);
-  if (doc.errors.length) throw new Error(`gcf/config.yml: ${doc.errors[0].message}`);
+  if (doc.errors.length) throw new Error(`${name}: ${doc.errors[0].message}`);
+  // A file of a list or a word on top is not a settings file: replacing it would lose it.
+  if (doc.contents != null && !YAML.isMap(doc.contents) && doc.contents.toJSON() != null)
+    throw new Error(`${name} must map its keys`);
   if (!YAML.isMap(doc.contents)) doc.contents = /** @type {any} */ (doc.createNode({}));
 
   return doc;
@@ -33,8 +44,24 @@ export function ensureMap(doc, keys, error) {
   doc.setIn(keys, doc.createNode({}));
 }
 
-/** @type {{ key: string, kind: Kind, label: string }[]} */
+/** @type {{ key: string, kind: Kind, label: string, file?: string, options?: string[] }[]} */
 export const SETTINGS = [
+  {
+    key: 'language.ui',
+    kind: 'language',
+    file: AIF_CONFIG,
+    options: LANGUAGES,
+    label:
+      'the language agents write to you in: questions, block reasons, inbox entries, lessons, ' +
+      'titles',
+  },
+  {
+    key: 'language.artifacts',
+    kind: 'language',
+    file: AIF_CONFIG,
+    options: LANGUAGES,
+    label: 'the language of plans and of the bodies of items that are not design units',
+  },
   {
     key: 'run_mode',
     kind: 'mode',
@@ -95,28 +122,54 @@ export const SETTINGS = [
 
 const BY_KEY = new Map(SETTINGS.map((s) => [s.key, s]));
 
+/** The default a setting holds while its file does not set it; the artifacts follow the ui. */
+function defaultOf(s, aif) {
+  const [head, sub] = s.key.split('.');
+  if (s.key === 'language.artifacts') return languageIn(aif, 'ui') ?? 'en';
+  if (s.kind === 'language') return 'en';
+  if (sub) return null;
+
+  return head === 'run_mode' ? 'worktree' : (DEFAULT_CONFIG[head] ?? null);
+}
+
 /**
- * Each setting with what the file sets (null: not set, the default holds) and its default:
- * what a settings screen shows. `raw` is the parsed config.yml, before the defaults.
+ * Each setting with what its file sets (null: not set, the default holds) and its default:
+ * what a settings screen shows. `raw` is the parsed config.yml, before the defaults; `aif` the
+ * parsed `.ai-factory/config.yaml`.
  */
-export function settingsOf(raw) {
+export function settingsOf(raw, aif = {}) {
   return SETTINGS.map((s) => {
     const [head, sub] = s.key.split('.');
-    const parent = raw?.[head];
+    const parent = (s.file ? aif : raw)?.[head];
     const value = sub
       ? parent && typeof parent === 'object'
         ? (parent[sub] ?? null)
         : null
       : (parent ?? null);
-    const def = sub ? null : head === 'run_mode' ? 'worktree' : (DEFAULT_CONFIG[head] ?? null);
+    // AI Factory's file is not checked by GCF's rules: a value that is no language shows unset.
+    const shown = s.file ? languageIn(aif, sub) : value;
 
-    return { ...s, value, default: def };
+    return { ...s, value: shown, default: defaultOf(s, aif) };
   });
 }
 
+/** Every setting as the project's two files have them. */
+export const projectSettings = async (projectDir) =>
+  settingsOf(await readRawConfig(gcfRoot(projectDir)), await readAifConfig(projectDir));
+
+/** A language name or code; empty takes the key off, and AI Factory's default holds. */
+function languageOf(setting, t) {
+  if (t && !LANGUAGE_RE.test(t))
+    throw new Error(`${setting.key} must be a language name or code (en, ru…), got ${t}`);
+
+  return t || null;
+}
+
 /** The value of `text` for a setting of `kind`; an empty number goes back to its default. */
 function valueOf(setting, text) {
   const t = String(text ?? '').trim();
+  if (setting.kind === 'language') return languageOf(setting, t);
+
   if (setting.kind === 'command') {
     if (!t) throw new Error(`${setting.key}: name the command, or none`);
 
@@ -138,45 +191,71 @@ function valueOf(setting, text) {
   return n;
 }
 
+/** Whether git ignores `file`: a commit cannot carry it, and a worktree does not have it. */
+const ignoredByGit = (projectDir, file) =>
+  spawnSync('git', ['check-ignore', '-q', '--', file], { cwd: projectDir }).status === 0;
+
+const trackedByGit = (projectDir, file) =>
+  spawnSync('git', ['ls-files', '--error-unmatch', '--', file], { cwd: projectDir }).status === 0;
+
 /**
- * Set one key of gcf/config.yml and commit gcf(config); a number set to nothing goes back to
- * its default. The file is read and checked under the move's lock.
+ * Set one key of gcf/config.yml, or the language of `.ai-factory/config.yaml`, and commit
+ * gcf(config); a number set to nothing goes back to its default. The file is read and checked
+ * under the move's lock. An AI Factory file git ignores is written, not committed (`ignored`).
  */
 export async function setConfig(projectDir, key, text, { commit = true } = {}) {
   const setting = BY_KEY.get(key);
   if (!setting) throw new Error(`no setting ${key}: ${SETTINGS.map((s) => s.key).join(' | ')}`);
   const value = valueOf(setting, text);
-  const file = path.join(gcfRoot(projectDir), 'config.yml');
+  const name = setting.file ?? 'gcf/config.yml';
+  const file = setting.file
+    ? path.join(path.resolve(projectDir), setting.file)
+    : path.join(gcfRoot(projectDir), 'config.yml');
+  const ignored = Boolean(setting.file) && ignoredByGit(projectDir, file);
+  // AI Factory's setup may leave its file uncommitted: the first change commits it whole.
+  const inputs = setting.file && !ignored && !trackedByGit(projectDir, file) ? [file] : [];
   const keys = key.split('.');
-  let raw;
   // A change that changes nothing (the same value, a reset of a key not set) commits nothing.
   let unchanged = false;
-  const hash = await commitMove(projectDir, `gcf(config): ${key}`, {
-    files: [file],
-    mutate: async () => {
-      const text = existsSync(file) ? await readFile(file, 'utf8') : '';
-      const doc = configDoc(text);
-      if (keys.length > 1)
-        ensureMap(doc, [keys[0]], `gcf/config.yml: ${keys[0]} must map its keys`);
-      if (value === null) doc.deleteIn(keys);
-      else doc.setIn(keys, value);
-      raw = doc.toJS();
-      configOf(raw);
-      const out = doc.toString();
-      // The values, not the text: YAML's output may differ in form (a final newline, `{}`).
-      if (isDeepStrictEqual(YAML.parse(text) ?? {}, raw ?? {})) {
-        unchanged = true;
-        throw NO_CHANGE;
-      }
-
-      await atomicWrite(file, out);
-    },
-    commit,
-  }).catch((e) => {
+  const move = () =>
+    commitMove(projectDir, `gcf(config): ${key}`, {
+      files: [file],
+      inputs,
+      mutate,
+      commit: commit && !ignored,
+    });
+  const mutate = async () => {
+    const text = existsSync(file) ? await readFile(file, 'utf8') : '';
+    const doc = configDoc(text, name);
+    // A reset of a key whose parent is not there changes nothing: no empty map is written.
+    if (value === null && keys.length > 1 && !YAML.isMap(doc.getIn([keys[0]], true))) {
+      unchanged = true;
+      throw NO_CHANGE;
+    }
+
+    if (keys.length > 1) ensureMap(doc, [keys[0]], `${name}: ${keys[0]} must map its keys`);
+    if (value === null) doc.deleteIn(keys);
+    else doc.setIn(keys, value);
+    const raw = doc.toJS();
+    if (!setting.file) configOf(raw);
+    const out = doc.toString();
+    // The values, not the text: YAML's output may differ in form (a final newline, `{}`).
+    if (isDeepStrictEqual(YAML.parse(text) ?? {}, raw ?? {})) {
+      unchanged = true;
+      throw NO_CHANGE;
+    }
+
+    await atomicWrite(file, out);
+  };
+
+  // A move that commits nothing takes no lock in commitMove: the ignored file still needs one.
+  const hash = await (ignored && commit ? withMainLock(projectDir, move) : move()).catch((e) => {
     if (e !== NO_CHANGE) throw e;
 
     return null;
   });
+  // The change is made: a broken gcf/config.yml must not read as its failure.
+  const settings = await projectSettings(projectDir).catch(() => []);
 
-  return { key, value, unchanged, settings: settingsOf(raw), hash };
+  return { key, value, unchanged, ignored, settings, hash };
 }