atris 3.30.1 → 3.30.3

package/lib/deck-schema.js

@@ -0,0 +1,154 @@
+// Deck spec schema validation — catch a bad spec before it hits the Slides API.
+//
+// lintSpec (lib/deck-review.js) judges *taste* (clip risk, template fatigue,
+// AI-tell copy). validateSpec judges *shape*: unknown slide types, missing
+// required fields, bad theme, malformed arrays. It runs on `deck lint` and
+// gates `deck build`, so a typo fails locally with a slide index instead of a
+// cryptic batch-update error after the network round trip.
+//
+// Findings share lintSpec's shape: { severity, slide, rule, message } where
+// slide 0 is a spec-level finding and slide N (1-based) points at a slide.
+
+const { THEMES, ARCHE } = require('./slides-deck');
+
+const KNOWN_THEMES = new Set(Object.keys(THEMES));
+
+// Per-type contract.
+//   need: list of alternative-groups; each group needs >=1 field with content.
+//   arr:  fields that, when present, must be non-empty arrays.
+// Keep this in lockstep with ARCHE in slides-deck.js (a drift test enforces it).
+const SLIDE_SCHEMA = {
+  title: { need: [['headline', 'title']], arr: {} },
+  statement: { need: [['text', 'headline']], arr: {} },
+  columns: { need: [['columns']], arr: { columns: { min: 1 } } },
+  panel: { need: [['panel']], arr: {} },
+  chips: { need: [['chips']], arr: { chips: { min: 1 } } },
+  bignumber: { need: [['number', 'value']], arr: {} },
+  close: { need: [], arr: { buttons: { min: 0 } } },
+  timeline: { need: [['steps']], arr: { steps: { min: 1 } } },
+  versus: { need: [['left'], ['right']], arr: {} },
+  metricgrid: { need: [['metrics']], arr: { metrics: { min: 1 } } },
+  receipt: { need: [['fields']], arr: { fields: { min: 1 } } },
+  stack: { need: [['layers']], arr: { layers: { min: 1 } } },
+  quote: { need: [['text']], arr: {} },
+  hero: { need: [['headline', 'text']], arr: {} },
+  interstitial: { need: [['text', 'headline']], arr: {} },
+  lede: { need: [['headline', 'title']], arr: {} },
+  prose: { need: [['paragraphs', 'body']], arr: { paragraphs: { min: 0 } } },
+  split: { need: [['body', 'text']], arr: {} },
+  bullets: { need: [['items']], arr: { items: { min: 1 } } },
+};
+
+function hasContent(v) {
+  if (v == null) return false;
+  if (typeof v === 'string') return v.trim().length > 0;
+  if (Array.isArray(v)) return v.length > 0;
+  if (typeof v === 'object') return Object.keys(v).length > 0;
+  return Boolean(v) || v === 0;
+}
+
+function validateSpec(spec) {
+  const findings = [];
+  if (!spec || typeof spec !== 'object' || Array.isArray(spec)) {
+    findings.push({ severity: 'error', slide: 0, rule: 'spec-shape', message: 'Spec must be a JSON object' });
+    return findings;
+  }
+  if (spec.theme != null && !KNOWN_THEMES.has(spec.theme)) {
+    findings.push({
+      severity: 'error',
+      slide: 0,
+      rule: 'unknown-theme',
+      message: `Unknown theme "${spec.theme}". Use: ${[...KNOWN_THEMES].join(', ')}`,
+    });
+  }
+  const slides = spec.slides;
+  if (!Array.isArray(slides) || slides.length === 0) {
+    findings.push({ severity: 'error', slide: 0, rule: 'no-slides', message: 'Spec needs a non-empty "slides" array' });
+    return findings;
+  }
+  slides.forEach((slide, i) => {
+    const n = i + 1;
+    if (!slide || typeof slide !== 'object' || Array.isArray(slide)) {
+      findings.push({ severity: 'error', slide: n, rule: 'slide-shape', message: 'Slide must be an object' });
+      return;
+    }
+    const type = slide.type;
+    if (!hasContent(type)) {
+      findings.push({ severity: 'error', slide: n, rule: 'missing-type', message: 'Slide is missing a "type"' });
+      return;
+    }
+    const def = SLIDE_SCHEMA[type];
+    if (!def) {
+      findings.push({
+        severity: 'error',
+        slide: n,
+        rule: 'unknown-slide-type',
+        message: `Unknown slide type "${type}". Known: ${Object.keys(SLIDE_SCHEMA).join(', ')}`,
+      });
+      return;
+    }
+    (def.need || []).forEach((alts) => {
+      if (!alts.some((k) => hasContent(slide[k]))) {
+        const label = alts.map((a) => `"${a}"`).join(' or ');
+        findings.push({ severity: 'error', slide: n, rule: 'missing-field', message: `"${type}" slide needs ${label}` });
+      }
+    });
+    Object.entries(def.arr || {}).forEach(([field, ruleDef]) => {
+      const v = slide[field];
+      if (v == null) return;
+      if (!Array.isArray(v)) {
+        findings.push({ severity: 'error', slide: n, rule: 'bad-array', message: `Slide field "${field}" must be an array` });
+      } else if (ruleDef.min && v.length < ruleDef.min) {
+        findings.push({ severity: 'warn', slide: n, rule: 'empty-array', message: `Slide field "${field}" is empty` });
+      }
+    });
+    // Nested arrays the flat `arr` contract can't reach: a non-array here would
+    // pass the gate and then crash the renderer, so check shape explicitly.
+    if (type === 'panel' && slide.panel && slide.panel.rows != null && !Array.isArray(slide.panel.rows)) {
+      findings.push({ severity: 'error', slide: n, rule: 'bad-array', message: 'panel.rows must be an array' });
+    }
+    if (type === 'versus') {
+      for (const side of ['left', 'right']) {
+        const items = slide[side] && slide[side].items;
+        if (items != null && !Array.isArray(items)) {
+          findings.push({ severity: 'error', slide: n, rule: 'bad-array', message: `versus ${side}.items must be an array` });
+        }
+      }
+    }
+  });
+  return findings;
+}
+
+// Order findings for display: spec-level first, then by slide, errors above warns.
+const SEV_RANK = { error: 0, warn: 1, info: 2 };
+function sortFindings(findings) {
+  return [...findings].sort((a, b) => {
+    if (a.slide !== b.slide) return a.slide - b.slide;
+    return (SEV_RANK[a.severity] ?? 3) - (SEV_RANK[b.severity] ?? 3);
+  });
+}
+
+function hasErrors(findings) {
+  return findings.some((f) => f.severity === 'error');
+}
+
+// Schema validation (shape) + lint (taste), merged and ordered.
+function checkSpec(spec, lintSpec) {
+  const schema = validateSpec(spec);
+  // Only run the taste lint when the shape is sane enough to walk slides.
+  const taste = !hasErrors(schema.filter((f) => f.rule === 'spec-shape' || f.rule === 'no-slides')) && typeof lintSpec === 'function'
+    ? lintSpec(spec)
+    : [];
+  return sortFindings([...schema, ...taste]);
+}
+
+module.exports = {
+  KNOWN_THEMES,
+  SLIDE_SCHEMA,
+  validateSpec,
+  sortFindings,
+  hasErrors,
+  hasContent,
+  checkSpec,
+  ARCHE_TYPES: Object.keys(ARCHE),
+};

package/lib/file-ops.js

@@ -105,8 +105,8 @@ function parseInboxItems(content) {
     if (trimmed.startsWith('(Empty')) return;
     const parsed = trimmed.match(/^- \*\*I(\d+):\*\*\s*(.+)$|^- \*\*I(\d+):\s+(.+)$/);
     if (parsed) {
-      const id = parseInt(parsed[1] || parsed[3], 10);
-      const text = parsed[2] || parsed[4];
+      const id = parseInt(parsed[1] !== undefined ? parsed[1] : parsed[3], 10);
+      const text = parsed[2] !== undefined ? parsed[2] : parsed[4];
       items.push({ id, text, line: trimmed });
     }
   });

package/lib/functional-owner.js

@@ -0,0 +1,189 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const escapeRegExp = require('./escape-regexp');
+
+const ENGINE_OWNER_IDS = new Set([
+  'atris-2-fast',
+  'atris2',
+  'atris2-fast',
+  'claude',
+  'codex',
+  'codex-executor',
+  'cursor',
+  'devin',
+  'executor',
+  'openclaw',
+  'windsurf',
+]);
+
+const FUNCTIONAL_MEMBER_TOPICS = [
+  {
+    owner: 'task-planner',
+    terms: ['task', 'plan', 'planner', 'planning', 'preview', 'landing', 'queue', 'backlog', 'owner', 'assignment', 'routing'],
+  },
+  {
+    owner: 'architect',
+    terms: ['member', 'team', 'factory', 'architecture', 'workflow', 'role', 'permission', 'policy', 'contract'],
+  },
+  {
+    owner: 'mission-lead',
+    terms: ['mission', 'overnight', '24/7', 'autonomy', 'always-on', 'loop', 'heartbeat', 'cadence', 'lease', 'goal'],
+  },
+  {
+    owner: 'validator',
+    terms: ['proof', 'review', 'verify', 'verifier', 'validation', 'test', 'check', 'inspect'],
+  },
+  {
+    owner: 'launcher',
+    terms: ['release', 'launch', 'publish', 'ship', 'dmg', 'zip', 'post'],
+  },
+  {
+    owner: 'researcher',
+    terms: ['research', 'paper', 'source', 'market', 'investigate'],
+  },
+  {
+    owner: 'wiki-miner',
+    terms: ['wiki', 'knowledge', 'map', 'docs', 'documentation', 'journal'],
+  },
+  {
+    owner: 'navigator',
+    terms: ['navigation', 'where', 'find', 'locate', 'map'],
+  },
+  {
+    owner: 'improver',
+    terms: ['improve', 'cleanup', 'clean', 'maintenance', 'tidy', 'stale'],
+  },
+  {
+    owner: 'signal-scout',
+    terms: ['signal', 'signals', 'error', 'failure', 'pattern', 'alert', 'watch', 'log', 'logs', 'infer'],
+  },
+];
+
+function normalizeOwnerSlug(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+function isEngineOwner(value) {
+  return ENGINE_OWNER_IDS.has(normalizeOwnerSlug(value));
+}
+
+function listWorkspaceMemberSlugs(root) {
+  const teamDir = path.join(root || process.cwd(), 'atris', 'team');
+  try {
+    return new Set(fs.readdirSync(teamDir, { withFileTypes: true })
+      .filter(entry => entry.isDirectory())
+      .map(entry => entry.name)
+      .filter(name => name !== '_template')
+      .filter(name => fs.existsSync(path.join(teamDir, name, 'MEMBER.md')))
+      .map(normalizeOwnerSlug));
+  } catch (_) {
+    return new Set();
+  }
+}
+
+function firstAvailableFunctionalOwner(candidates, existingMembers) {
+  for (const candidate of candidates) {
+    const owner = normalizeOwnerSlug(candidate);
+    if (!owner) continue;
+    if (existingMembers.size === 0 || existingMembers.has(owner)) return owner;
+  }
+  return null;
+}
+
+function ownerTermScore(text, term, weight = 1) {
+  const haystack = String(text || '').toLowerCase();
+  const needle = String(term || '').toLowerCase();
+  if (!haystack || !needle) return 0;
+  if (/^[a-z0-9-]+$/.test(needle)) {
+    const re = new RegExp(`(^|[^a-z0-9])${escapeRegExp(needle)}([^a-z0-9]|$)`, 'i');
+    return re.test(haystack) ? weight : 0;
+  }
+  return haystack.includes(needle) ? weight : 0;
+}
+
+function proposedMemberSlugFromTask({ title, tag }) {
+  const source = normalizeOwnerSlug(tag && tag !== true ? tag : title);
+  const core = source
+    .split('-')
+    .filter(part => part && !['add', 'build', 'create', 'design', 'fix', 'make', 'replace', 'ship', 'the', 'with'].includes(part))
+    .slice(0, 3)
+    .join('-');
+  return `${core || 'feature'}-owner`;
+}
+
+function resolveFunctionalOwner({ requestedOwner, title, tag, note, goal, root, fallbackOwners } = {}) {
+  const requested = normalizeOwnerSlug(requestedOwner);
+  const existingMembers = listWorkspaceMemberSlugs(root);
+  const highSignalText = [title, note, goal].filter(Boolean).join(' ').toLowerCase();
+  const tagText = tag && tag !== true ? String(tag).toLowerCase() : '';
+  const text = [highSignalText, tagText].filter(Boolean).join(' ');
+
+  if (requested && !isEngineOwner(requested)) {
+    return {
+      owner: requested,
+      reason: 'explicit_functional_owner',
+      requested_owner: requested,
+    };
+  }
+
+  const exact = firstAvailableFunctionalOwner(
+    FUNCTIONAL_MEMBER_TOPICS.filter(topic => text.includes(topic.owner)).map(topic => topic.owner),
+    existingMembers
+  );
+  if (exact) {
+    return {
+      owner: exact,
+      reason: requested ? 'engine_owner_resolved_by_exact_member' : 'inferred_exact_member',
+      requested_owner: requested || null,
+      executed_by: requested && isEngineOwner(requested) ? requested : null,
+    };
+  }
+
+  const scored = FUNCTIONAL_MEMBER_TOPICS
+    .map(topic => ({
+      owner: topic.owner,
+      score: topic.terms.reduce((sum, term) => (
+        sum
+        + ownerTermScore(highSignalText, term, 3)
+        + ownerTermScore(tagText, term, 1)
+      ), 0),
+    }))
+    .filter(row => row.score > 0)
+    .sort((a, b) => b.score - a.score);
+  const inferred = firstAvailableFunctionalOwner(scored.map(row => row.owner), existingMembers);
+  if (inferred) {
+    return {
+      owner: inferred,
+      reason: requested ? 'engine_owner_resolved_by_task_signal' : 'inferred_by_task_signal',
+      requested_owner: requested || null,
+      executed_by: requested && isEngineOwner(requested) ? requested : null,
+    };
+  }
+
+  const fallback = firstAvailableFunctionalOwner(fallbackOwners || ['architect', 'task-planner', 'mission-lead', 'validator'], existingMembers)
+    || Array.from(existingMembers).find(owner => !isEngineOwner(owner))
+    || 'architect';
+  return {
+    owner: fallback,
+    reason: requested ? 'engine_owner_resolved_to_factory_owner' : 'missing_functional_owner_fit',
+    requested_owner: requested || null,
+    executed_by: requested && isEngineOwner(requested) ? requested : null,
+    proposed_member: proposedMemberSlugFromTask({ title, tag }),
+  };
+}
+
+module.exports = {
+  ENGINE_OWNER_IDS,
+  FUNCTIONAL_MEMBER_TOPICS,
+  normalizeOwnerSlug,
+  isEngineOwner,
+  listWorkspaceMemberSlugs,
+  proposedMemberSlugFromTask,
+  resolveFunctionalOwner,
+};