@ijfw/memory-server 1.4.4 → 1.5.1

package/src/team/modify.js

@@ -0,0 +1,203 @@
+// F-FUN-4 + F-FUN-5 (audit-MED-teams-#7 + #13): team-charter mutation
+// helpers. Honors the SKILL.md "Custom Agent Requests" promise -- users can
+// add, remove, swap, list, and check roles on their custom team without
+// hand-editing JSON.
+//
+// Every mutating helper:
+//   1. Reads the current charter/workflow.
+//   2. Applies the mutation in-memory.
+//   3. Validates the resulting charter via team/schemas.js.
+//   4. Writes the charter back atomically.
+//   5. Re-runs syncCodexAgents so .codex/agents/ stays in lockstep.
+//
+// `checkTeamAssembly` is the standalone validator surfaced by
+// `ijfw team check` -- it does not write anything and does not require
+// `ijfw swarm plan` to surface error messages.
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { writeAtomic } from '../lib/atomic-io.js';
+import { syncCodexAgents } from '../codex-agents.js';
+import { readTeamAssembly } from './generator.js';
+import { validateTeamCharter, validateWorkflowManifest } from './schemas.js';
+
+function teamPaths(root) {
+  return {
+    charterPath: join(root, '.ijfw', 'team', 'charter.json'),
+    workflowPath: join(root, '.ijfw', 'team', 'workflow.json'),
+  };
+}
+
+function loadCharter(root) {
+  const { charterPath } = teamPaths(root);
+  if (!existsSync(charterPath)) return null;
+  return JSON.parse(readFileSync(charterPath, 'utf8'));
+}
+
+function loadWorkflow(root) {
+  const { workflowPath } = teamPaths(root);
+  if (!existsSync(workflowPath)) return null;
+  return JSON.parse(readFileSync(workflowPath, 'utf8'));
+}
+
+function writeCharter(root, charter) {
+  const { charterPath } = teamPaths(root);
+  writeAtomic(charterPath, `${JSON.stringify(charter, null, 2)}\n`, { mode: 0o600 });
+  return charterPath;
+}
+
+/**
+ * List the current roles + summary metadata for the team. Returns a
+ * structured payload so callers (CLI + future MCP tool) can render however
+ * they like.
+ */
+export function listTeamRoles(projectRoot = process.cwd()) {
+  const root = resolve(projectRoot);
+  const charter = loadCharter(root);
+  if (!charter) return { ok: false, error: 'missing-charter' };
+  const roles = Array.isArray(charter.roles) ? charter.roles : [];
+  return {
+    ok: true,
+    team_name: charter.team_name || null,
+    project_archetypes: charter.project_archetypes || [],
+    roles: roles.map((r) => ({
+      name: r.name,
+      role_type: r.role_type,
+      model: r.model,
+      effort: r.effort || 'medium',
+      phase_scope: r.phase_scope || [],
+    })),
+  };
+}
+
+/**
+ * Add a role to the charter. The charter is supplied as a JSON path; we
+ * read+validate it before splicing in. Triggers a codex agent re-sync.
+ */
+export function addTeamRole(projectRoot, { charterPath, role }) {
+  const root = resolve(projectRoot);
+  const charter = loadCharter(root);
+  if (!charter) return { ok: false, error: 'missing-charter' };
+
+  const incoming = role || readJsonFile(charterPath);
+  if (!incoming || typeof incoming !== 'object') return { ok: false, error: 'invalid-role-payload' };
+  if (!incoming.name) return { ok: false, error: 'role-name-required' };
+
+  const existing = (charter.roles || []).find((r) => r.name === incoming.name);
+  if (existing) return { ok: false, error: 'role-exists', name: incoming.name };
+
+  const next = { ...charter, roles: [...(charter.roles || []), incoming] };
+  const validation = validateTeamCharter(next);
+  if (!validation.ok) return { ok: false, error: 'invalid-charter', errors: validation.errors };
+
+  writeCharter(root, next);
+  const codex = syncCodexAgents(root);
+  return { ok: true, role: incoming, codex };
+}
+
+/**
+ * Remove a role by name. Refuses if removing the role would leave the
+ * charter invalid (e.g. last role).
+ */
+export function removeTeamRole(projectRoot, { name }) {
+  const root = resolve(projectRoot);
+  const charter = loadCharter(root);
+  if (!charter) return { ok: false, error: 'missing-charter' };
+
+  const before = (charter.roles || []).length;
+  const roles = (charter.roles || []).filter((r) => r.name !== name);
+  if (roles.length === before) return { ok: false, error: 'role-not-found', name };
+
+  const next = { ...charter, roles };
+  const validation = validateTeamCharter(next);
+  if (!validation.ok) return { ok: false, error: 'invalid-charter', errors: validation.errors };
+
+  writeCharter(root, next);
+  const codex = syncCodexAgents(root);
+  return { ok: true, removed: name, codex };
+}
+
+/**
+ * Replace one role with another. `oldName` must exist; `replacement` is a
+ * full role object (or path to a JSON file describing one).
+ */
+export function swapTeamRole(projectRoot, { oldName, charterPath, replacement }) {
+  const root = resolve(projectRoot);
+  const charter = loadCharter(root);
+  if (!charter) return { ok: false, error: 'missing-charter' };
+
+  const incoming = replacement || readJsonFile(charterPath);
+  if (!incoming || typeof incoming !== 'object') return { ok: false, error: 'invalid-role-payload' };
+  if (!incoming.name) return { ok: false, error: 'role-name-required' };
+
+  const roles = charter.roles || [];
+  const idx = roles.findIndex((r) => r.name === oldName);
+  if (idx === -1) return { ok: false, error: 'role-not-found', name: oldName };
+
+  // Name collision when the replacement keeps a *different* existing name.
+  if (incoming.name !== oldName && roles.some((r) => r.name === incoming.name)) {
+    return { ok: false, error: 'role-exists', name: incoming.name };
+  }
+
+  const nextRoles = roles.slice();
+  nextRoles[idx] = incoming;
+  const next = { ...charter, roles: nextRoles };
+  const validation = validateTeamCharter(next);
+  if (!validation.ok) return { ok: false, error: 'invalid-charter', errors: validation.errors };
+
+  writeCharter(root, next);
+  const codex = syncCodexAgents(root);
+  return { ok: true, swapped: { old: oldName, new: incoming.name }, codex };
+}
+
+/**
+ * F-FUN-5 (audit-MED-teams-#13): standalone team validation. Returns a
+ * structured pass/fail report so the CLI can render a human-readable list
+ * without forcing the caller into `ijfw swarm plan`.
+ */
+export function checkTeamAssembly(projectRoot = process.cwd()) {
+  const root = resolve(projectRoot);
+  const charter = loadCharter(root);
+  const workflow = loadWorkflow(root);
+  const report = {
+    ok: true,
+    has_charter: Boolean(charter),
+    has_workflow: Boolean(workflow),
+    charter: { ok: true, errors: [] },
+    workflow: { ok: true, errors: [] },
+    role_count: 0,
+    artifact_count: 0,
+  };
+  if (!charter) {
+    report.ok = false;
+    report.charter = { ok: false, errors: ['charter.json is missing -- run: ijfw team init'] };
+  } else {
+    const c = validateTeamCharter(charter);
+    report.charter = c;
+    report.role_count = Array.isArray(charter.roles) ? charter.roles.length : 0;
+    if (!c.ok) report.ok = false;
+  }
+  if (!workflow) {
+    report.ok = false;
+    report.workflow = { ok: false, errors: ['workflow.json is missing -- run: ijfw team init'] };
+  } else {
+    const w = validateWorkflowManifest(workflow, charter);
+    report.workflow = w;
+    report.artifact_count = Array.isArray(workflow.artifacts) ? workflow.artifacts.length : 0;
+    if (!w.ok) report.ok = false;
+  }
+  return report;
+}
+
+function readJsonFile(path) {
+  if (!path) return null;
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+// Re-exports for the CLI surface so it can `import * as teamModify`.
+export { readTeamAssembly };

package/src/team/schemas.js

@@ -10,6 +10,54 @@ const ARCHETYPES = new Set([
   'mixed',
 ]);
 
+// T24 / G7-core: canonical software-core agent ids. Mirrored by
+// `SOFTWARE_CORE_AGENT_IDS` in generator.js — this re-export gives
+// schema-side consumers (validators, downstream tools, T25's domain-aware
+// generator) a single source of truth without circular import on
+// generator.js. Any change to the set MUST update both locations and the
+// matching `claude/agents/<id>.md` files on disk.
+export const SOFTWARE_CORE_AGENT_IDS = Object.freeze([
+  'ijfw-doc-verifier',
+  'ijfw-integration-checker',
+  'ijfw-nyquist-auditor',
+  'ijfw-code-fixer',
+]);
+
+// T25 / G7-gen: canonical domain-specialist agent ids by archetype. The map
+// is the single source of truth for which specialist ids the generator
+// returns for each domain — T26 will author the matching
+// `claude/agents/<id>.md` files so the installer can deploy them; T25 just
+// makes the generator hand them back per archetype.
+//
+// Contract:
+//   - keys are normalized archetypes (post-alias-map). `book`, `content`,
+//     and `design` are populated today; other archetypes get `[]` until
+//     T26 expands the set.
+//   - values are deterministic arrays; insertion order is roster-display order.
+//   - software domain's specialists are the SOFTWARE_CORE_AGENT_IDS — this
+//     map intentionally does NOT duplicate them (`resolveDomainSpecialistAgentIds`
+//     in generator.js returns the union for software). Non-software domains
+//     own their own specialist lists exclusively.
+//
+// Choice of three+ domains (`book`, `content`, `design`) satisfies the
+// "≥3 non-software domains" constraint and gives T26 concrete templates
+// to flesh out. Other archetypes will gain rosters in later tasks.
+export const DOMAIN_SPECIALIST_AGENT_IDS = Object.freeze({
+  book: Object.freeze([
+    'ijfw-narrative-continuity-checker',
+    'ijfw-line-editor',
+    'ijfw-lore-keeper',
+  ]),
+  content: Object.freeze([
+    'ijfw-campaign-strategist',
+    'ijfw-copy-reviewer',
+  ]),
+  design: Object.freeze([
+    'ijfw-design-critic',
+    'ijfw-accessibility-reviewer',
+  ]),
+});
+
 const ROLE_TYPES = new Set([
   'lead',
   'software',

package/src/update-apply.js

@@ -1,5 +1,14 @@
 // MCP tool: ijfw_update_apply
 //
+// @deprecated since v1.5.0; will be removed in v1.6.0 (F-FUN-3 / v1.5.0 audit-MED-M7).
+// `ijfw_update_check` already issues a confirmation token whose instruction tells
+// the user to type `ijfw update --confirm <token>` in their terminal directly.
+// The intermediate `ijfw_update_apply` step writes a pending sentinel, but the
+// terminal CLI does not require the sentinel to confirm — the token itself is
+// authoritative. The tool is retained for v1.5.0 back-compat (older skills that
+// still call it work unchanged) and slated for retirement in v1.6.0 to free the
+// MCP-tool slot (see CLAUDE.md "MCP server: ≤13 tools" cap).
+//
 // Does NOT execute the update. Validates the token, writes (or overwrites)
 // the pending sentinel, returns instruction telling the user to run the
 // terminal-side confirm command. Idempotent against a matching sentinel
@@ -10,6 +19,11 @@
 import { validateToken, writePendingSentinel } from './lib/token.js';
 import { isVersionStringValid } from './lib/npm-view.js';
 
+/**
+ * @deprecated since v1.5.0; scheduled for removal in v1.6.0. Callers should
+ * skip straight from `ijfw_update_check` to the terminal-side confirm command;
+ * the intermediate sentinel write is redundant given the token contract.
+ */
 export function ijfwUpdateApply(args = {}) {
   const { target_version, confirmation_token } = args || {};
   const sessionId = args.session_id || process.env.IJFW_SESSION_ID || 'default-session';
@@ -64,9 +78,11 @@ export function ijfwUpdateApply(args = {}) {
 export const TOOL_DEF = {
   name: 'ijfw_update_apply',
   description:
-    'Stage an IJFW update behind out-of-band terminal confirmation. Writes a pending sentinel; ' +
-    "actual update only runs when the user types 'ijfw update --confirm <token>' in their terminal. " +
-    'This MCP tool NEVER executes the update directly.',
+    '[DEPRECATED v1.5.0; removal in v1.6.0] Stage an IJFW update behind out-of-band terminal ' +
+    'confirmation. Writes a pending sentinel; actual update only runs when the user types ' +
+    "'ijfw update --confirm <token>' in their terminal. This MCP tool NEVER executes the " +
+    'update directly. Prefer calling ijfw_update_check and forwarding the returned ' +
+    "'ijfw update --confirm <token>' instruction directly to the user.",
   inputSchema: {
     type: 'object',
     required: ['target_version', 'confirmation_token'],

package/src/dashboard-charts.js

@@ -1,239 +0,0 @@
-/**
- * dashboard-charts.js — IJFW v1.4.3 W9-C (B19)
- *
- * Pure-JS canvas/DOM chart helpers for the dashboard. No external libs.
- * Theme-aware: reads CSS custom properties `--ijfw-chart-fg`,
- * `--ijfw-chart-bg`, `--ijfw-chart-warning` from the element's computed
- * style. Falls back to sane defaults if the host page hasn't set them.
- *
- * All helpers are defensive against malformed input so a bad payload from
- * the API can never throw inside the dashboard render loop.
- */
-
-const DEFAULTS = {
-  fg: '#9ad2ff',
-  bg: 'rgba(154,210,255,0.18)',
-  warning: '#ff9b3a',
-  text: '#cfd6dd',
-};
-
-function _readTheme(el) {
-  // Both `canvas` and plain `div` go through `getComputedStyle`. In the test
-  // environment the element is a hand-rolled mock that doesn't reach the DOM
-  // — guard so we don't blow up if `getComputedStyle` is unavailable.
-  let cs = null;
-  try {
-    if (el && typeof globalThis.getComputedStyle === 'function') {
-      cs = globalThis.getComputedStyle(el);
-    }
-  } catch { cs = null; }
-  const read = (prop, fallback) => {
-    if (!cs || typeof cs.getPropertyValue !== 'function') return fallback;
-    const v = cs.getPropertyValue(prop);
-    return (v && v.trim()) ? v.trim() : fallback;
-  };
-  return {
-    fg:      read('--ijfw-chart-fg',      DEFAULTS.fg),
-    bg:      read('--ijfw-chart-bg',      DEFAULTS.bg),
-    warning: read('--ijfw-chart-warning', DEFAULTS.warning),
-    text:    read('--ijfw-chart-text',    DEFAULTS.text),
-  };
-}
-
-function _safeNum(v, def = 0) {
-  return (typeof v === 'number' && Number.isFinite(v)) ? v : def;
-}
-
-/**
- * lineChart(canvas, points, opts)
- *   points: [{ x: number, y: number }, ...] OR [number, ...]
- *   opts:   { xMin?, xMax?, yMax?, color?, fill? }
- *
- * Empty data renders nothing (clears the canvas) without throwing.
- */
-export function lineChart(canvas, points, opts = {}) {
-  if (!canvas || typeof canvas.getContext !== 'function') return;
-  const ctx = canvas.getContext('2d');
-  if (!ctx) return;
-  const W = _safeNum(canvas.width, 200);
-  const H = _safeNum(canvas.height, 100);
-  const theme = _readTheme(canvas);
-  const color = opts.color || theme.fg;
-  const fill  = opts.fill === false ? null : theme.bg;
-
-  try { ctx.clearRect(0, 0, W, H); } catch {}
-
-  const pts = Array.isArray(points) ? points : [];
-  const norm = pts.map((p, i) => {
-    if (typeof p === 'number') return { x: i, y: _safeNum(p, 0) };
-    return { x: _safeNum(p && p.x, i), y: _safeNum(p && p.y, 0) };
-  }).filter((p) => Number.isFinite(p.x) && Number.isFinite(p.y));
-
-  if (norm.length === 0) return;
-
-  let xMin = _safeNum(opts.xMin, norm[0].x);
-  let xMax = _safeNum(opts.xMax, norm[norm.length - 1].x);
-  if (xMax === xMin) xMax = xMin + 1;
-  const yMax = _safeNum(opts.yMax, Math.max(1, ...norm.map((p) => p.y)));
-  const yScale = yMax > 0 ? yMax : 1;
-
-  const pad = 4;
-  const innerW = Math.max(1, W - pad * 2);
-  const innerH = Math.max(1, H - pad * 2);
-
-  const px = (x) => pad + ((x - xMin) / (xMax - xMin)) * innerW;
-  const py = (y) => pad + (1 - (Math.max(0, y) / yScale)) * innerH;
-
-  // Filled area
-  if (fill) {
-    try {
-      ctx.beginPath();
-      ctx.moveTo(px(norm[0].x), H - pad);
-      for (const p of norm) ctx.lineTo(px(p.x), py(p.y));
-      ctx.lineTo(px(norm[norm.length - 1].x), H - pad);
-      ctx.closePath();
-      ctx.fillStyle = fill;
-      ctx.fill();
-    } catch {}
-  }
-
-  // Line stroke
-  try {
-    ctx.beginPath();
-    ctx.moveTo(px(norm[0].x), py(norm[0].y));
-    for (let i = 1; i < norm.length; i++) ctx.lineTo(px(norm[i].x), py(norm[i].y));
-    ctx.strokeStyle = color;
-    ctx.lineWidth   = 1.5;
-    ctx.stroke();
-  } catch {}
-}
-
-/**
- * barChart(canvas, bars, opts)
- *   bars: [{ label: string, value: number, color?: string }, ...]
- *   opts: { horizontal?: boolean, color?: string, maxValue?: number }
- *
- * Zero-value bars render as empty rails. Negative values are clamped to 0.
- */
-export function barChart(canvas, bars, opts = {}) {
-  if (!canvas || typeof canvas.getContext !== 'function') return;
-  const ctx = canvas.getContext('2d');
-  if (!ctx) return;
-  const W = _safeNum(canvas.width, 200);
-  const H = _safeNum(canvas.height, 100);
-  const theme = _readTheme(canvas);
-  const defaultColor = opts.color || theme.fg;
-  const horizontal = Boolean(opts.horizontal);
-
-  try { ctx.clearRect(0, 0, W, H); } catch {}
-
-  const rows = Array.isArray(bars) ? bars.filter((b) => b && typeof b === 'object') : [];
-  if (rows.length === 0) return;
-
-  const values = rows.map((b) => Math.max(0, _safeNum(b.value, 0)));
-  const maxVal = _safeNum(opts.maxValue, Math.max(1, ...values));
-  const scale = maxVal > 0 ? maxVal : 1;
-
-  const pad = 4;
-  const labelGutter = horizontal ? 80 : 14;
-  const innerW = Math.max(1, W - pad * 2 - (horizontal ? labelGutter : 0));
-  const innerH = Math.max(1, H - pad * 2 - (horizontal ? 0 : labelGutter));
-  const slot = (horizontal ? innerH : innerW) / rows.length;
-  const barW = Math.max(1, slot * 0.7);
-
-  for (let i = 0; i < rows.length; i++) {
-    const b = rows[i];
-    const v = values[i];
-    const color = b.color || defaultColor;
-    if (horizontal) {
-      const y = pad + i * slot + (slot - barW) / 2;
-      const len = (v / scale) * innerW;
-      try {
-        ctx.fillStyle = theme.bg;
-        ctx.fillRect(pad + labelGutter, y, innerW, barW);
-        ctx.fillStyle = color;
-        ctx.fillRect(pad + labelGutter, y, len, barW);
-        ctx.fillStyle = theme.text;
-        ctx.fillText(String(b.label || ''), pad, y + barW * 0.75);
-      } catch {}
-    } else {
-      const x = pad + i * slot + (slot - barW) / 2;
-      const len = (v / scale) * innerH;
-      try {
-        ctx.fillStyle = theme.bg;
-        ctx.fillRect(x, pad, barW, innerH);
-        ctx.fillStyle = color;
-        ctx.fillRect(x, pad + (innerH - len), barW, len);
-        ctx.fillStyle = theme.text;
-        ctx.fillText(String(b.label || '').slice(0, 8), x, H - pad);
-      } catch {}
-    }
-  }
-}
-
-/**
- * progressBar(div, data)
- *   data: { current: number, limit: number | null, label?: string, warning?: boolean }
- *
- * Mutates `div` in place. Renders an "unlimited" placeholder when limit is
- * null. Applies a warning class when `warning` is truthy.
- */
-export function progressBar(div, data = {}) {
-  if (!div) return;
-  const theme = _readTheme(div);
-  const cur = Math.max(0, _safeNum(data.current, 0));
-  const lim = (data.limit === null || data.limit === undefined) ? null : _safeNum(data.limit, null);
-  const label = typeof data.label === 'string' ? data.label : '';
-  const warn = Boolean(data.warning);
-
-  // Clear children.
-  try {
-    while (div.firstChild) div.removeChild(div.firstChild);
-  } catch {
-    // Some test mocks omit firstChild/removeChild. Skip cleanup.
-  }
-
-  const setClass = (extra) => {
-    try {
-      div.className = ['ijfw-progress', extra, warn ? 'ijfw-progress--warn' : '']
-        .filter(Boolean).join(' ');
-    } catch {}
-  };
-
-  // Helper to create child elements safely.
-  function appendEl(tag, opts) {
-    try {
-      if (typeof div.ownerDocument === 'object' && div.ownerDocument && typeof div.ownerDocument.createElement === 'function') {
-        const el = div.ownerDocument.createElement(tag);
-        if (opts && opts.text) el.textContent = opts.text;
-        if (opts && opts.style) el.setAttribute('style', opts.style);
-        if (opts && opts.cls) el.className = opts.cls;
-        if (typeof div.appendChild === 'function') div.appendChild(el);
-        return el;
-      }
-    } catch {}
-    return null;
-  }
-
-  if (lim === null) {
-    setClass('ijfw-progress--unlimited');
-    appendEl('span', { cls: 'ijfw-progress-label', text: label });
-    appendEl('span', { cls: 'ijfw-progress-val',   text: cur + ' / unlimited' });
-    return;
-  }
-
-  setClass('');
-  const denom = lim > 0 ? lim : 1;
-  const pct = Math.max(0, Math.min(100, (cur / denom) * 100));
-  appendEl('span', { cls: 'ijfw-progress-label', text: label });
-  const rail = appendEl('span', { cls: 'ijfw-progress-rail', style: 'background:' + theme.bg + ';display:inline-block;height:6px;width:120px;border-radius:3px;overflow:hidden;vertical-align:middle;margin:0 6px' });
-  if (rail) {
-    try {
-      const fill = (rail.ownerDocument || div.ownerDocument).createElement('span');
-      fill.className = 'ijfw-progress-fill';
-      fill.setAttribute('style', 'display:block;height:100%;width:' + pct.toFixed(1) + '%;background:' + (warn ? theme.warning : theme.fg));
-      rail.appendChild(fill);
-    } catch {}
-  }
-  appendEl('span', { cls: 'ijfw-progress-val', text: cur + ' / ' + lim });
-}