chati-dev 1.4.0 → 2.0.1

package/src/installer/core.js

@@ -3,7 +3,7 @@ import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { IDE_CONFIGS } from '../config/ide-configs.js';
 import { generateClaudeMCPConfig } from '../config/mcp-configs.js';
-import { generateSessionYaml, generateConfigYaml, generateClaudeMd } from './templates.js';
+import { generateSessionYaml, generateConfigYaml, generateClaudeMd, generateClaudeLocalMd } from './templates.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -37,7 +37,8 @@ export async function installFramework(config) {
     'agents/clarity', 'agents/quality', 'agents/build', 'agents/deploy',
     'templates', 'workflows', 'quality-gates',
     'schemas', 'frameworks', 'intelligence', 'patterns',
-    'i18n', 'migrations', 'data',
+    'hooks', 'domains', 'domains/agents', 'domains/workflows',
+    'i18n', 'migrations', 'data', 'context',
     'artifacts/0-WU', 'artifacts/1-Brief', 'artifacts/2-PRD',
     'artifacts/3-Architecture', 'artifacts/4-UX', 'artifacts/5-Phases',
     'artifacts/6-Tasks', 'artifacts/7-QA-Planning', 'artifacts/8-Validation',
@@ -84,12 +85,30 @@ export async function installFramework(config) {
     await configureIDE(targetDir, ideKey, selectedMCPs);
   }
 
-  // 4. Create/update CLAUDE.md at root
+  // 4. Copy context files to .claude/rules/chati/ (auto-loaded by Claude Code)
+  const rulesDir = join(targetDir, '.claude', 'rules', 'chati');
+  createDir(rulesDir);
+  const contextFiles = ['root.md', 'governance.md', 'protocols.md', 'quality.md'];
+  for (const file of contextFiles) {
+    const src = join(FRAMEWORK_SOURCE, 'context', file);
+    if (existsSync(src)) {
+      copyFileSync(src, join(rulesDir, file));
+    }
+  }
+
+  // 5. Create CLAUDE.md (minimal — framework rules auto-loaded from .claude/rules/chati/)
   writeFileSync(
     join(targetDir, 'CLAUDE.md'),
     generateClaudeMd({ projectName, projectType, language }),
     'utf-8'
   );
+
+  // 6. Create CLAUDE.local.md (runtime state — session lock, current agent)
+  writeFileSync(
+    join(targetDir, 'CLAUDE.local.md'),
+    generateClaudeLocalMd(),
+    'utf-8'
+  );
 }
 
 /**
@@ -149,6 +168,34 @@ function copyFrameworkFiles(destDir) {
     'intelligence/decision-engine.md',
     // Patterns
     'patterns/elicitation.md',
+    // Hooks
+    'hooks/prism-engine.js',
+    'hooks/mode-governance.js',
+    'hooks/constitution-guard.js',
+    'hooks/session-digest.js',
+    'hooks/model-governance.js',
+    'hooks/settings.json',
+    // Domains (PRISM Context Engine)
+    'domains/constitution.yaml',
+    'domains/global.yaml',
+    'domains/agents/orchestrator.yaml',
+    'domains/agents/greenfield-wu.yaml',
+    'domains/agents/brownfield-wu.yaml',
+    'domains/agents/brief.yaml',
+    'domains/agents/detail.yaml',
+    'domains/agents/architect.yaml',
+    'domains/agents/ux.yaml',
+    'domains/agents/phases.yaml',
+    'domains/agents/tasks.yaml',
+    'domains/agents/qa-planning.yaml',
+    'domains/agents/qa-implementation.yaml',
+    'domains/agents/dev.yaml',
+    'domains/agents/devops.yaml',
+    'domains/workflows/greenfield-fullstack.yaml',
+    'domains/workflows/brownfield-fullstack.yaml',
+    'domains/workflows/brownfield-discovery.yaml',
+    'domains/workflows/brownfield-service.yaml',
+    'domains/workflows/brownfield-ui.yaml',
     // i18n
     'i18n/en.yaml',
     'i18n/pt.yaml',
@@ -158,6 +205,11 @@ function copyFrameworkFiles(destDir) {
     'migrations/v1.0-to-v1.1.yaml',
     // Data
     'data/entity-registry.yaml',
+    // Context (@ import chain for CLAUDE.md)
+    'context/root.md',
+    'context/governance.md',
+    'context/protocols.md',
+    'context/quality.md',
   ];
 
   for (const file of filesToCopy) {

package/src/installer/file-hasher.js

@@ -0,0 +1,51 @@
+import { readFileSync } from 'fs';
+import { createHash } from 'crypto';
+
+/**
+ * Normalize line endings: CRLF -> LF
+ * Ensures consistent hashing across platforms.
+ */
+function normalizeLineEndings(content) {
+  return content.replace(/\r\n/g, '\n');
+}
+
+/**
+ * Compute SHA-256 hash of a string content.
+ * Normalizes line endings before hashing.
+ *
+ * @param {string} content - The string content to hash
+ * @returns {string} Hex-encoded SHA-256 digest
+ */
+export function hashContent(content) {
+  const normalized = normalizeLineEndings(content);
+  return createHash('sha256').update(normalized, 'utf-8').digest('hex');
+}
+
+/**
+ * Compute SHA-256 hash of a file.
+ * Reads the file as UTF-8, normalizes line endings, then hashes.
+ *
+ * @param {string} filePath - Absolute path to the file
+ * @returns {string} Hex-encoded SHA-256 digest
+ */
+export function hashFile(filePath) {
+  const content = readFileSync(filePath, 'utf-8');
+  return hashContent(content);
+}
+
+/**
+ * Compare two files by their SHA-256 hashes.
+ *
+ * @param {string} pathA - Absolute path to first file
+ * @param {string} pathB - Absolute path to second file
+ * @returns {{ match: boolean, hashA: string, hashB: string }}
+ */
+export function compareFiles(pathA, pathB) {
+  const hashA = hashFile(pathA);
+  const hashB = hashFile(pathB);
+  return {
+    match: hashA === hashB,
+    hashA,
+    hashB,
+  };
+}

package/src/installer/manifest.js

@@ -0,0 +1,117 @@
+import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { hashFile } from './file-hasher.js';
+
+const MANIFEST_FILENAME = 'manifest.json';
+const MANIFEST_DIR = '.chati';
+
+/**
+ * Generate a manifest for a set of files under a root directory.
+ *
+ * @param {string} rootDir - Root directory to scan from
+ * @param {string[]} relativePaths - Array of relative file paths to include
+ * @param {string} [version='0.0.0'] - Version string for the manifest
+ * @returns {{ version: string, createdAt: string, files: Record<string, { hash: string, size: number, type: string }> }}
+ */
+export function generateManifest(rootDir, relativePaths, version = '0.0.0') {
+  const files = {};
+
+  for (const relPath of relativePaths) {
+    const absPath = join(rootDir, relPath);
+    if (!existsSync(absPath)) continue;
+
+    const stat = statSync(absPath);
+    if (!stat.isFile()) continue;
+
+    const hash = hashFile(absPath);
+    const ext = relPath.split('.').pop() || '';
+    files[relPath] = {
+      hash,
+      size: stat.size,
+      type: ext,
+    };
+  }
+
+  return {
+    version,
+    createdAt: new Date().toISOString(),
+    files,
+  };
+}
+
+/**
+ * Save a manifest to .chati/manifest.json inside the target directory.
+ *
+ * @param {string} targetDir - Target project directory
+ * @param {object} manifest - The manifest object to save
+ */
+export function saveManifest(targetDir, manifest) {
+  const manifestDir = join(targetDir, MANIFEST_DIR);
+  if (!existsSync(manifestDir)) {
+    mkdirSync(manifestDir, { recursive: true });
+  }
+
+  const manifestPath = join(manifestDir, MANIFEST_FILENAME);
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
+}
+
+/**
+ * Load a manifest from .chati/manifest.json inside the target directory.
+ *
+ * @param {string} targetDir - Target project directory
+ * @returns {object|null} The manifest object, or null if not found
+ */
+export function loadManifest(targetDir) {
+  const manifestPath = join(targetDir, MANIFEST_DIR, MANIFEST_FILENAME);
+  if (!existsSync(manifestPath)) return null;
+
+  const raw = readFileSync(manifestPath, 'utf-8');
+  return JSON.parse(raw);
+}
+
+/**
+ * Compare two manifests to find added, removed, modified, and unchanged files.
+ *
+ * @param {object} oldManifest - Previous manifest
+ * @param {object} newManifest - New manifest
+ * @returns {{ added: string[], removed: string[], modified: string[], unchanged: string[] }}
+ */
+export function compareManifests(oldManifest, newManifest) {
+  const oldFiles = oldManifest.files || {};
+  const newFiles = newManifest.files || {};
+
+  const oldKeys = new Set(Object.keys(oldFiles));
+  const newKeys = new Set(Object.keys(newFiles));
+
+  const added = [];
+  const removed = [];
+  const modified = [];
+  const unchanged = [];
+
+  // Files in new but not in old => added
+  for (const key of newKeys) {
+    if (!oldKeys.has(key)) {
+      added.push(key);
+    }
+  }
+
+  // Files in old but not in new => removed
+  for (const key of oldKeys) {
+    if (!newKeys.has(key)) {
+      removed.push(key);
+    }
+  }
+
+  // Files in both => compare hashes
+  for (const key of oldKeys) {
+    if (newKeys.has(key)) {
+      if (oldFiles[key].hash === newFiles[key].hash) {
+        unchanged.push(key);
+      } else {
+        modified.push(key);
+      }
+    }
+  }
+
+  return { added, removed, modified, unchanged };
+}

package/src/installer/templates.js

@@ -64,7 +64,7 @@ export function generateConfigYaml(config) {
 }
 
 /**
- * Generate CLAUDE.md content
+ * Generate CLAUDE.md content (minimal — framework rules auto-loaded from .claude/rules/chati/)
  */
 export function generateClaudeMd(config) {
   const { projectName, projectType, language } = config;
@@ -73,32 +73,34 @@ export function generateClaudeMd(config) {
 
 ## Project Context
 - **Type**: ${projectType === 'greenfield' ? 'Greenfield (new project)' : 'Brownfield (existing project)'}
-- **State**: CLARITY (planning phase)
 - **Language**: ${language}
-- **Current Agent**: None (ready to start)
 
-## Quick Start
-Type \`/chati\` to activate the orchestrator. It will guide you through the entire process.
+## chati.dev
+Framework rules loaded from \`.claude/rules/chati/\`. Runtime state in \`CLAUDE.local.md\`.
+Type \`/chati\` to start.
+`;
+}
+
+/**
+ * Generate CLAUDE.local.md content (runtime state — auto-gitignored, never committed)
+ */
+export function generateClaudeLocalMd() {
+  return `# chati.dev Runtime State
 
 ## Session Lock
 **Status: INACTIVE** — Type \`/chati\` to activate.
 
-When active, ALL messages are routed through the chati.dev orchestrator. The user stays inside the system until they explicitly exit with \`/chati exit\`.
-
 <!-- SESSION-LOCK:INACTIVE -->
 
-## Key Files
-- **Session**: \`.chati/session.yaml\` (runtime state)
-- **Constitution**: \`chati.dev/constitution.md\` (governance)
-- **Orchestrator**: \`chati.dev/orchestrator/chati.md\` (entry point)
-
-## Pipeline
-CLARITY (planning) -> BUILD (implementation) -> VALIDATE -> DEPLOY
+## Current State
+- **Agent**: None (ready to start)
+- **Pipeline**: Pre-start
+- **Mode**: interactive
 
 ## Recent Decisions
 _No decisions yet. Start with /chati._
 
 ---
-_Auto-updated by chati.dev agents (Protocol 5.4)_
+_Auto-updated by chati.dev orchestrator_
 `;
 }

package/src/installer/transaction.js

@@ -0,0 +1,229 @@
+import {
+  existsSync,
+  mkdirSync,
+  writeFileSync,
+  unlinkSync,
+  rmSync,
+  copyFileSync,
+} from 'fs';
+import { join, dirname } from 'path';
+
+/**
+ * Transaction states.
+ * @readonly
+ * @enum {string}
+ */
+const STATE = {
+  PENDING: 'pending',
+  ACTIVE: 'active',
+  COMMITTED: 'committed',
+  ROLLED_BACK: 'rolled_back',
+};
+
+/**
+ * Atomic installation transaction with rollback support.
+ * Creates a backup before making changes, and can revert
+ * all operations if something goes wrong.
+ */
+export class InstallTransaction {
+  /**
+   * @param {string} targetDir - The target directory for the installation
+   */
+  constructor(targetDir) {
+    this._targetDir = targetDir;
+    this._state = STATE.PENDING;
+    this._backupDir = null;
+    this._operations = [];
+    this._reverseOps = [];
+  }
+
+  /**
+   * Get the current transaction state.
+   * @returns {'pending' | 'active' | 'committed' | 'rolled_back'}
+   */
+  getState() {
+    return this._state;
+  }
+
+  /**
+   * Begin the transaction.
+   * Creates a backup directory and snapshots the current state.
+   */
+  begin() {
+    if (this._state !== STATE.PENDING) {
+      throw new Error(`Cannot begin transaction in state: ${this._state}`);
+    }
+
+    const timestamp = Date.now();
+    this._backupDir = join(this._targetDir, '.chati', `backup-${timestamp}`);
+    mkdirSync(this._backupDir, { recursive: true });
+
+    this._state = STATE.ACTIVE;
+    this._operations = [];
+    this._reverseOps = [];
+  }
+
+  /**
+   * Execute a list of operations within the transaction.
+   * Each operation is recorded with its reverse for potential rollback.
+   *
+   * @param {Array<{ type: 'write'|'delete'|'mkdir', path: string, content?: string }>} operations
+   */
+  execute(operations) {
+    if (this._state !== STATE.ACTIVE) {
+      throw new Error(`Cannot execute operations in state: ${this._state}`);
+    }
+
+    for (const op of operations) {
+      const absPath = join(this._targetDir, op.path);
+
+      switch (op.type) {
+        case 'write': {
+          // Backup existing file if it exists
+          if (existsSync(absPath)) {
+            const backupPath = join(this._backupDir, op.path);
+            mkdirSync(dirname(backupPath), { recursive: true });
+            copyFileSync(absPath, backupPath);
+            this._reverseOps.unshift({
+              type: 'restore',
+              path: op.path,
+              backupPath,
+              absPath,
+            });
+          } else {
+            this._reverseOps.unshift({
+              type: 'delete',
+              absPath,
+            });
+          }
+
+          // Execute write
+          mkdirSync(dirname(absPath), { recursive: true });
+          writeFileSync(absPath, op.content || '', 'utf-8');
+          this._operations.push(op);
+          break;
+        }
+
+        case 'delete': {
+          // Backup existing file before deleting
+          if (existsSync(absPath)) {
+            const backupPath = join(this._backupDir, op.path);
+            mkdirSync(dirname(backupPath), { recursive: true });
+            copyFileSync(absPath, backupPath);
+            this._reverseOps.unshift({
+              type: 'restore',
+              path: op.path,
+              backupPath,
+              absPath,
+            });
+
+            unlinkSync(absPath);
+          }
+          this._operations.push(op);
+          break;
+        }
+
+        case 'mkdir': {
+          if (!existsSync(absPath)) {
+            mkdirSync(absPath, { recursive: true });
+            this._reverseOps.unshift({
+              type: 'rmdir',
+              absPath,
+            });
+          }
+          this._operations.push(op);
+          break;
+        }
+
+        default:
+          throw new Error(`Unknown operation type: ${op.type}`);
+      }
+    }
+  }
+
+  /**
+   * Commit the transaction.
+   * Marks the transaction as complete and cleans up the backup directory.
+   *
+   * @returns {{ success: true, operationsExecuted: number }}
+   */
+  commit() {
+    if (this._state !== STATE.ACTIVE) {
+      throw new Error(`Cannot commit transaction in state: ${this._state}`);
+    }
+
+    // Clean up backup
+    if (this._backupDir && existsSync(this._backupDir)) {
+      rmSync(this._backupDir, { recursive: true, force: true });
+    }
+
+    this._state = STATE.COMMITTED;
+    return {
+      success: true,
+      operationsExecuted: this._operations.length,
+    };
+  }
+
+  /**
+   * Rollback the transaction.
+   * Reverses all operations that were executed, restoring from backup.
+   *
+   * @returns {{ success: true, operationsRolledBack: number }}
+   */
+  rollback() {
+    if (this._state !== STATE.ACTIVE) {
+      throw new Error(`Cannot rollback transaction in state: ${this._state}`);
+    }
+
+    let rolledBack = 0;
+
+    for (const reverseOp of this._reverseOps) {
+      try {
+        switch (reverseOp.type) {
+          case 'restore': {
+            // Restore file from backup
+            mkdirSync(dirname(reverseOp.absPath), { recursive: true });
+            copyFileSync(reverseOp.backupPath, reverseOp.absPath);
+            rolledBack++;
+            break;
+          }
+
+          case 'delete': {
+            // Delete a file that was created during the transaction
+            if (existsSync(reverseOp.absPath)) {
+              unlinkSync(reverseOp.absPath);
+              rolledBack++;
+            }
+            break;
+          }
+
+          case 'rmdir': {
+            // Remove directory that was created (only if empty)
+            if (existsSync(reverseOp.absPath)) {
+              try {
+                rmSync(reverseOp.absPath, { recursive: true, force: true });
+                rolledBack++;
+              } catch {
+                // Directory may not be empty due to other changes; skip
+              }
+            }
+            break;
+          }
+        }
+      } catch {
+        // Best-effort rollback: continue even if individual reversals fail
+      }
+    }
+
+    // Clean up backup directory
+    if (this._backupDir && existsSync(this._backupDir)) {
+      rmSync(this._backupDir, { recursive: true, force: true });
+    }
+
+    this._state = STATE.ROLLED_BACK;
+    return {
+      success: true,
+      operationsRolledBack: rolledBack,
+    };
+  }
+}

package/src/installer/validator.js

@@ -16,6 +16,7 @@ export async function validateInstallation(targetDir) {
     intelligence: { pass: false, details: [] },
     registry: { pass: false, details: [] },
     memories: { pass: false, details: [] },
+    context: { pass: false, details: [] },
     total: 0,
     passed: 0,
   };
@@ -59,7 +60,7 @@ export async function validateInstallation(targetDir) {
   if (existsSync(constitutionPath)) {
     const content = readFileSync(constitutionPath, 'utf-8');
     const articleCount = (content.match(/^## Article/gm) || []).length;
-    results.constitution.pass = articleCount >= 16;
+    results.constitution.pass = articleCount >= 17;
     results.constitution.details.push({ articleCount });
   }
   results.total += 1;
@@ -149,5 +150,21 @@ export async function validateInstallation(targetDir) {
   results.total += 1;
   if (results.memories.pass) results.passed += 1;
 
+  // Check context files (source in chati.dev/context/, deployed to .claude/rules/chati/)
+  const contextFileNames = ['root.md', 'governance.md', 'protocols.md', 'quality.md'];
+  let contextCount = 0;
+  for (const file of contextFileNames) {
+    // Check source (chati.dev/context/) OR deployed (.claude/rules/chati/)
+    const inSource = existsSync(join(targetDir, 'chati.dev', 'context', file));
+    const inRules = existsSync(join(targetDir, '.claude', 'rules', 'chati', file));
+    if (inSource || inRules) {
+      contextCount++;
+    }
+  }
+  results.context.pass = contextCount === 4;
+  results.context.details.push({ found: contextCount, expected: 4 });
+  results.total += 1;
+  if (results.context.pass) results.passed += 1;
+
   return results;
 }