chati-dev 1.4.0 → 2.0.1

package/src/context/formatter.js

@@ -0,0 +1,184 @@
+/**
+ * Context Formatter — Produces structured XML for agent prompt injection.
+ *
+ * Output format: <chati-context bracket="..."> with nested sections.
+ * Truncates intelligently based on token budget via priority-based pruning.
+ */
+
+/**
+ * Format PRISM pipeline results into XML context block.
+ * @param {object} options
+ * @param {string} options.bracket - Current bracket name
+ * @param {number} options.tokenBudget - Max approximate token count
+ * @param {object} options.l0 - L0 Constitution result
+ * @param {object} [options.l1] - L1 Global result
+ * @param {object} [options.l2] - L2 Agent result
+ * @param {object} [options.l3] - L3 Workflow result
+ * @param {object} [options.l4] - L4 Task result
+ * @returns {string} XML context block
+ */
+export function formatContext(options) {
+  const { bracket, tokenBudget, l0, l1, l2, l3, l4 } = options;
+  const sections = [];
+
+  // L0 — Constitution (always present)
+  if (l0) {
+    sections.push(formatConstitution(l0));
+  }
+
+  // L1 — Mode + Global
+  if (l1) {
+    sections.push(formatGlobal(l1));
+  }
+
+  // L2 — Agent
+  if (l2 && l2.agent) {
+    sections.push(formatAgent(l2));
+  }
+
+  // L3 — Pipeline/Workflow
+  if (l3 && l3.workflow) {
+    sections.push(formatWorkflow(l3));
+  }
+
+  // L4 — Task
+  if (l4 && l4.taskId) {
+    sections.push(formatTask(l4));
+  }
+
+  let body = sections.join('\n\n');
+
+  // Truncate if over budget (rough estimate: 1 token ≈ 4 chars)
+  const maxChars = tokenBudget * 4;
+  if (body.length > maxChars) {
+    body = truncateByPriority(sections, maxChars);
+  }
+
+  return `<chati-context bracket="${bracket}">\n${body}\n</chati-context>`;
+}
+
+function formatConstitution(l0) {
+  const rulesText = l0.rules.length > 0
+    ? l0.rules.map(r => `    <rule id="${esc(r.id)}" priority="${esc(r.priority)}">${esc(r.text)}</rule>`).join('\n')
+    : `    <summary>${esc(l0.summary)}</summary>`;
+
+  return `  <constitution articles="${l0.articleCount}">\n${rulesText}\n  </constitution>`;
+}
+
+function formatGlobal(l1) {
+  const lines = [];
+  lines.push(`  <mode name="${esc(l1.mode)}">`);
+  if (l1.modeRules.writeScope) {
+    lines.push(`    <write-scope>${esc(l1.modeRules.writeScope)}</write-scope>`);
+  }
+  if (l1.modeRules.allowedActions.length > 0) {
+    lines.push(`    <allowed>${l1.modeRules.allowedActions.map(esc).join(', ')}</allowed>`);
+  }
+  if (l1.modeRules.blockedActions.length > 0) {
+    lines.push(`    <blocked>${l1.modeRules.blockedActions.map(esc).join(', ')}</blocked>`);
+  }
+  lines.push(`  </mode>`);
+
+  if (l1.rules.length > 0) {
+    lines.push(`  <global-rules>`);
+    for (const r of l1.rules) {
+      lines.push(`    <rule id="${esc(r.id)}">${esc(r.text)}</rule>`);
+    }
+    lines.push(`  </global-rules>`);
+  }
+
+  return lines.join('\n');
+}
+
+function formatAgent(l2) {
+  const lines = [];
+  lines.push(`  <agent name="${esc(l2.agent)}">`);
+  if (l2.mission) {
+    lines.push(`    <mission>${esc(l2.mission)}</mission>`);
+  }
+  if (l2.authority.exclusive.length > 0) {
+    lines.push(`    <exclusive>${l2.authority.exclusive.map(esc).join(', ')}</exclusive>`);
+  }
+  if (l2.authority.blocked.length > 0) {
+    lines.push(`    <blocked>${l2.authority.blocked.map(esc).join(', ')}</blocked>`);
+  }
+  if (l2.outputs.length > 0) {
+    lines.push(`    <outputs>${l2.outputs.map(esc).join(', ')}</outputs>`);
+  }
+  if (l2.rules.length > 0) {
+    for (const r of l2.rules) {
+      lines.push(`    <rule id="${esc(r.id)}">${esc(r.text)}</rule>`);
+    }
+  }
+  lines.push(`  </agent>`);
+  return lines.join('\n');
+}
+
+function formatWorkflow(l3) {
+  const p = l3.pipelineContext;
+  const lines = [];
+  lines.push(`  <pipeline workflow="${esc(l3.workflow)}" progress="${p.progress}%">`);
+  if (p.previousStep) lines.push(`    <previous>${esc(p.previousStep)}</previous>`);
+  if (p.currentStep) lines.push(`    <current>${esc(p.currentStep)}</current>`);
+  if (p.nextStep) lines.push(`    <next>${esc(p.nextStep)}</next>`);
+  if (l3.rules.length > 0) {
+    for (const r of l3.rules) {
+      lines.push(`    <rule id="${esc(r.id)}">${esc(r.text)}</rule>`);
+    }
+  }
+  lines.push(`  </pipeline>`);
+  return lines.join('\n');
+}
+
+function formatTask(l4) {
+  const lines = [];
+  lines.push(`  <task id="${esc(l4.taskId)}">`);
+  if (l4.criteria.length > 0) {
+    lines.push(`    <criteria>`);
+    for (const c of l4.criteria) {
+      lines.push(`      <criterion>${esc(c)}</criterion>`);
+    }
+    lines.push(`    </criteria>`);
+  }
+  if (l4.artifacts.length > 0) {
+    lines.push(`    <artifacts>${l4.artifacts.map(esc).join(', ')}</artifacts>`);
+  }
+  if (Object.keys(l4.handoff).length > 0) {
+    lines.push(`    <handoff>`);
+    for (const [key, val] of Object.entries(l4.handoff)) {
+      lines.push(`      <${esc(key)}>${esc(String(val))}</${esc(key)}>`);
+    }
+    lines.push(`    </handoff>`);
+  }
+  lines.push(`  </task>`);
+  return lines.join('\n');
+}
+
+/**
+ * Truncate sections by removing lower-priority layers first (L4 → L3 → L2).
+ * L0 and L1 are never truncated.
+ */
+function truncateByPriority(sections, maxChars) {
+  let result = sections.join('\n\n');
+  // Remove from end (lowest priority) until within budget
+  const trimmed = [...sections];
+  while (trimmed.length > 2 && result.length > maxChars) {
+    trimmed.pop();
+    result = trimmed.join('\n\n');
+  }
+  // If still over, hard truncate
+  if (result.length > maxChars) {
+    result = result.slice(0, maxChars) + '\n  <!-- truncated -->';
+  }
+  return result;
+}
+
+/** Escape XML special characters */
+function esc(str) {
+  if (!str) return '';
+  return String(str)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}

package/src/context/index.js

@@ -0,0 +1,4 @@
+export { runPrism, getPrismInfo } from './engine.js';
+export { calculateBracket, estimateRemaining, isLayerActive, getBracketDefinitions } from './bracket-tracker.js';
+export { formatContext } from './formatter.js';
+export { loadDomainFile, loadAgentDomains, loadWorkflowDomains, extractRules } from './domain-loader.js';

package/src/context/layers/l0-constitution.js

@@ -0,0 +1,28 @@
+/**
+ * L0 Constitution Layer — ALWAYS active, non-negotiable.
+ *
+ * Loads constitution rules from domain file. These are the fundamental
+ * governance rules that every agent must follow at all times.
+ */
+
+import { loadConstitutionDomain, extractRules } from '../domain-loader.js';
+
+/**
+ * Process L0: load constitution governance rules.
+ * @param {object} ctx - Pipeline context
+ * @param {string} ctx.domainsDir - Path to chati.dev/domains/
+ * @returns {{ layer: string, rules: Array, summary: string }}
+ */
+export function processL0(ctx) {
+  const domain = loadConstitutionDomain(ctx.domainsDir);
+  const rules = extractRules(domain);
+
+  const summary = domain?.summary || 'Constitution governance: self-validation, quality >= 95%, guided options, persistent state, two-layer handoff, language protocol, deviation protocol, mode governance.';
+
+  return {
+    layer: 'L0',
+    rules,
+    summary,
+    articleCount: domain?.articleCount || rules.length,
+  };
+}

package/src/context/layers/l1-global.js

@@ -0,0 +1,37 @@
+/**
+ * L1 Global Layer — ALWAYS active.
+ *
+ * Loads global rules: coding standards, bracket-specific behavioral rules,
+ * mode governance constraints (clarity/build/deploy).
+ */
+
+import { loadGlobalDomain, extractRules } from '../domain-loader.js';
+
+/**
+ * Process L1: load global rules + mode governance.
+ * @param {object} ctx - Pipeline context
+ * @param {string} ctx.domainsDir - Path to chati.dev/domains/
+ * @param {string} ctx.mode - Current mode (clarity, build, deploy)
+ * @param {string} ctx.bracket - Current bracket (FRESH, MODERATE, etc.)
+ * @returns {{ layer: string, rules: Array, mode: string, modeRules: object }}
+ */
+export function processL1(ctx) {
+  const domain = loadGlobalDomain(ctx.domainsDir);
+  const rules = extractRules(domain);
+  const mode = ctx.mode || 'clarity';
+
+  const modeRules = domain?.modes?.[mode] || {};
+  const bracketRules = domain?.brackets?.[ctx.bracket] || {};
+
+  return {
+    layer: 'L1',
+    rules,
+    mode,
+    modeRules: {
+      writeScope: modeRules.writeScope || 'chati.dev/',
+      allowedActions: modeRules.allowedActions || [],
+      blockedActions: modeRules.blockedActions || [],
+    },
+    bracketBehavior: bracketRules.behavior || 'normal',
+  };
+}

package/src/context/layers/l2-agent.js

@@ -0,0 +1,39 @@
+/**
+ * L2 Agent Layer — Active when an agent is assigned.
+ *
+ * Loads agent-specific domain rules: authority boundaries,
+ * behavioral rules, and task registry.
+ */
+
+import { loadAgentDomains, extractRules } from '../domain-loader.js';
+
+/**
+ * Process L2: load agent domain rules.
+ * @param {object} ctx - Pipeline context
+ * @param {string} ctx.domainsDir - Path to chati.dev/domains/
+ * @param {string} ctx.agent - Active agent name (e.g. 'brief', 'dev', 'orchestrator')
+ * @returns {{ layer: string, agent: string, rules: Array, authority: object }}
+ */
+export function processL2(ctx) {
+  if (!ctx.agent) {
+    return { layer: 'L2', agent: null, rules: [], authority: {} };
+  }
+
+  const allDomains = loadAgentDomains(ctx.domainsDir);
+  const domain = allDomains.get(ctx.agent) || null;
+  const rules = extractRules(domain);
+
+  return {
+    layer: 'L2',
+    agent: ctx.agent,
+    rules,
+    authority: {
+      exclusive: domain?.authority?.exclusive || [],
+      allowed: domain?.authority?.allowed || [],
+      blocked: domain?.authority?.blocked || [],
+      redirectMessage: domain?.authority?.redirectMessage || null,
+    },
+    mission: domain?.mission || '',
+    outputs: domain?.outputs || [],
+  };
+}

package/src/context/layers/l3-workflow.js

@@ -0,0 +1,42 @@
+/**
+ * L3 Workflow/Pipeline Layer — Active when session has pipeline state.
+ *
+ * Loads workflow rules with phase awareness: what came before,
+ * what comes next, and constraints for the current pipeline position.
+ */
+
+import { loadWorkflowDomains, extractRules } from '../domain-loader.js';
+
+/**
+ * Process L3: load workflow rules with pipeline awareness.
+ * @param {object} ctx - Pipeline context
+ * @param {string} ctx.domainsDir - Path to chati.dev/domains/
+ * @param {string} ctx.workflow - Active workflow name (e.g. 'greenfield-fullstack')
+ * @param {string} ctx.pipelinePosition - Current position in pipeline (e.g. 'brief')
+ * @returns {{ layer: string, workflow: string, rules: Array, pipelineContext: object }}
+ */
+export function processL3(ctx) {
+  if (!ctx.workflow) {
+    return { layer: 'L3', workflow: null, rules: [], pipelineContext: {} };
+  }
+
+  const allDomains = loadWorkflowDomains(ctx.domainsDir);
+  const domain = allDomains.get(ctx.workflow) || null;
+  const rules = extractRules(domain);
+
+  const steps = domain?.steps || [];
+  const currentIdx = steps.indexOf(ctx.pipelinePosition);
+
+  return {
+    layer: 'L3',
+    workflow: ctx.workflow,
+    rules,
+    pipelineContext: {
+      currentStep: ctx.pipelinePosition || null,
+      previousStep: currentIdx > 0 ? steps[currentIdx - 1] : null,
+      nextStep: currentIdx >= 0 && currentIdx < steps.length - 1 ? steps[currentIdx + 1] : null,
+      totalSteps: steps.length,
+      progress: steps.length > 0 ? Math.round(((currentIdx + 1) / steps.length) * 100) : 0,
+    },
+  };
+}

package/src/context/layers/l4-task.js

@@ -0,0 +1,24 @@
+/**
+ * L4 Task Layer — Active when a specific task is running.
+ *
+ * Injects task-specific context: the active task definition,
+ * handoff data from the previous agent, and relevant artifacts.
+ */
+
+/**
+ * Process L4: inject task context and handoff data.
+ * @param {object} ctx - Pipeline context
+ * @param {string} [ctx.taskId] - Active task ID (e.g. 'brief-extract')
+ * @param {object} [ctx.handoff] - Handoff data from previous agent
+ * @param {string[]} [ctx.artifacts] - List of artifact paths relevant to current task
+ * @returns {{ layer: string, taskId: string|null, handoff: object, artifacts: string[] }}
+ */
+export function processL4(ctx) {
+  return {
+    layer: 'L4',
+    taskId: ctx.taskId || null,
+    handoff: ctx.handoff || {},
+    artifacts: ctx.artifacts || [],
+    criteria: ctx.taskCriteria || [],
+  };
+}

package/src/decision/analyzer.js

@@ -0,0 +1,167 @@
+/**
+ * Impact Analyzer - Dependency analysis for chati.dev
+ * Analyzes impact of changes via dependency graph traversal
+ *
+ * @module decision/analyzer
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import yaml from 'js-yaml';
+
+/**
+ * Analyze impact of changing an entity.
+ * Builds dependency graph from entity-registry and calculates affected entities.
+ *
+ * @param {string} projectDir
+ * @param {string} entityPath - Path of entity being changed
+ * @returns {{ impactLevel: 'low'|'medium'|'high'|'critical', affectedEntities: object[], dependencyChain: string[] }}
+ */
+export function analyzeImpact(projectDir, entityPath) {
+  const graph = buildDependencyGraph(projectDir);
+  const affectedPaths = getTransitiveDependents(graph, entityPath);
+
+  // Determine impact level based on affected entity count
+  let impactLevel;
+  const affectedCount = affectedPaths.length;
+
+  if (affectedCount === 0) {
+    impactLevel = 'low';
+  } else if (affectedCount <= 2) {
+    impactLevel = 'low';
+  } else if (affectedCount <= 5) {
+    impactLevel = 'medium';
+  } else if (affectedCount <= 10) {
+    impactLevel = 'high';
+  } else {
+    impactLevel = 'critical';
+  }
+
+  // Load entity details
+  const registryPath = join(projectDir, 'chati.dev', 'entity-registry.yaml');
+  const registry = existsSync(registryPath)
+    ? yaml.load(readFileSync(registryPath, 'utf8'))
+    : { entities: {} };
+
+  const allEntities = flattenEntities(registry);
+  const entityMap = new Map(allEntities.map(e => [e.path, e]));
+
+  const affectedEntities = affectedPaths.map(path => {
+    const entity = entityMap.get(path);
+    return {
+      path,
+      type: entity?.type || 'unknown',
+      name: entity?.name || path.split('/').pop()
+    };
+  });
+
+  return {
+    impactLevel,
+    affectedEntities,
+    dependencyChain: affectedPaths
+  };
+}
+
+/**
+ * Build dependency graph from entity registry.
+ * @param {string} projectDir
+ * @returns {Map<string, string[]>} Map of entityPath -> [dependentPaths]
+ */
+export function buildDependencyGraph(projectDir) {
+  const registryPath = join(projectDir, 'chati.dev', 'entity-registry.yaml');
+  const graph = new Map();
+
+  if (!existsSync(registryPath)) {
+    return graph;
+  }
+
+  const registry = yaml.load(readFileSync(registryPath, 'utf8'));
+  const entities = flattenEntities(registry);
+
+  // Initialize graph with all entities
+  entities.forEach(entity => {
+    if (entity.path) {
+      graph.set(entity.path, []);
+    }
+  });
+
+  // Build reverse dependency map (who depends on whom)
+  entities.forEach(entity => {
+    if (entity.dependencies && Array.isArray(entity.dependencies)) {
+      entity.dependencies.forEach(depPath => {
+        if (!graph.has(depPath)) {
+          graph.set(depPath, []);
+        }
+        // Add entity.path as dependent of depPath
+        const dependents = graph.get(depPath);
+        if (!dependents.includes(entity.path)) {
+          dependents.push(entity.path);
+        }
+      });
+    }
+  });
+
+  return graph;
+}
+
+/**
+ * Get all entities that depend on a given entity (transitive).
+ * Uses BFS traversal.
+ * @param {Map<string, string[]>} graph
+ * @param {string} entityPath
+ * @returns {string[]} All affected paths
+ */
+export function getTransitiveDependents(graph, entityPath) {
+  const visited = new Set();
+  const queue = [entityPath];
+  const result = [];
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+
+    if (visited.has(current)) {
+      continue;
+    }
+
+    visited.add(current);
+
+    // Get direct dependents
+    const dependents = graph.get(current) || [];
+
+    dependents.forEach(dependent => {
+      if (!visited.has(dependent)) {
+        queue.push(dependent);
+        result.push(dependent);
+      }
+    });
+  }
+
+  return result;
+}
+
+/**
+ * Flatten entity registry into array of entities.
+ * @private
+ * @param {object} registry
+ * @returns {object[]}
+ */
+function flattenEntities(registry) {
+  const entities = [];
+
+  if (!registry.entities) {
+    return entities;
+  }
+
+  Object.entries(registry.entities).forEach(([type, typeEntities]) => {
+    if (Array.isArray(typeEntities)) {
+      typeEntities.forEach(entity => {
+        entities.push({
+          ...entity,
+          type
+        });
+      });
+    }
+  });
+
+  return entities;
+}