chati-dev 1.0.0

package/src/installer/core.js

@@ -0,0 +1,221 @@
+import { mkdirSync, writeFileSync, copyFileSync, existsSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import yaml from 'js-yaml';
+import { IDE_CONFIGS } from '../config/ide-configs.js';
+import { generateClaudeMCPConfig } from '../config/mcp-configs.js';
+import { generateSessionYaml, generateConfigYaml, generateClaudeMd } from './templates.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// When published to npm: framework files are bundled at packages/chati-dev/framework/
+// When developing locally in monorepo: fallback to monorepo root chati.dev/
+const BUNDLED_SOURCE = join(__dirname, '..', '..', 'framework');
+const MONOREPO_SOURCE = join(__dirname, '..', '..', '..', '..', 'chati.dev');
+const FRAMEWORK_SOURCE = existsSync(BUNDLED_SOURCE) ? BUNDLED_SOURCE : MONOREPO_SOURCE;
+
+/**
+ * Install chati.dev framework into target directory
+ */
+export async function installFramework(config) {
+  const { targetDir, projectType, language, selectedIDEs, selectedMCPs, projectName, version } = config;
+
+  // 1. Create .chati/ session directory
+  createDir(join(targetDir, '.chati'));
+  writeFileSync(
+    join(targetDir, '.chati', 'session.yaml'),
+    generateSessionYaml({ projectName, projectType, language, selectedIDEs, selectedMCPs }),
+    'utf-8'
+  );
+
+  // 2. Create chati.dev/ framework directory (copy from source)
+  const frameworkDir = join(targetDir, 'chati.dev');
+  createDir(frameworkDir);
+
+  // Copy framework structure
+  const frameworkDirs = [
+    'orchestrator',
+    'agents/clarity', 'agents/quality', 'agents/build', 'agents/deploy',
+    'templates', 'workflows', 'quality-gates',
+    'schemas', 'frameworks', 'intelligence', 'patterns',
+    'i18n', 'migrations',
+    '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',
+    'artifacts/handoffs', 'artifacts/decisions',
+  ];
+
+  for (const dir of frameworkDirs) {
+    createDir(join(frameworkDir, dir));
+  }
+
+  // Copy framework files from source
+  copyFrameworkFiles(frameworkDir);
+
+  // Write config.yaml
+  writeFileSync(
+    join(frameworkDir, 'config.yaml'),
+    generateConfigYaml({ version, projectType, language, selectedIDEs }),
+    'utf-8'
+  );
+
+  // 3. Configure IDEs
+  for (const ideKey of selectedIDEs) {
+    await configureIDE(targetDir, ideKey, selectedMCPs);
+  }
+
+  // 4. Create/update CLAUDE.md at root
+  writeFileSync(
+    join(targetDir, 'CLAUDE.md'),
+    generateClaudeMd({ projectName, projectType, language }),
+    'utf-8'
+  );
+}
+
+/**
+ * Copy framework files from the chati.dev source directory
+ */
+function copyFrameworkFiles(destDir) {
+  if (!existsSync(FRAMEWORK_SOURCE)) return;
+
+  const filesToCopy = [
+    'constitution.md',
+    'orchestrator/chati.md',
+    // CLARITY agents
+    'agents/clarity/greenfield-wu.md',
+    'agents/clarity/brownfield-wu.md',
+    'agents/clarity/brief.md',
+    'agents/clarity/detail.md',
+    'agents/clarity/architect.md',
+    'agents/clarity/ux.md',
+    'agents/clarity/phases.md',
+    'agents/clarity/tasks.md',
+    // Quality agents
+    'agents/quality/qa-planning.md',
+    'agents/quality/qa-implementation.md',
+    // BUILD + DEPLOY agents
+    'agents/build/dev.md',
+    'agents/deploy/devops.md',
+    // Templates
+    'templates/prd-tmpl.yaml',
+    'templates/brownfield-prd-tmpl.yaml',
+    'templates/fullstack-architecture-tmpl.yaml',
+    'templates/task-tmpl.yaml',
+    'templates/qa-gate-tmpl.yaml',
+    // Workflows
+    'workflows/greenfield-fullstack.yaml',
+    'workflows/brownfield-fullstack.yaml',
+    'workflows/brownfield-discovery.yaml',
+    'workflows/brownfield-service.yaml',
+    'workflows/brownfield-ui.yaml',
+    // Quality gates
+    'quality-gates/planning-gate.md',
+    'quality-gates/implementation-gate.md',
+    // Schemas
+    'schemas/session.schema.json',
+    'schemas/config.schema.json',
+    'schemas/task.schema.json',
+    // Frameworks
+    'frameworks/quality-dimensions.yaml',
+    'frameworks/decision-heuristics.yaml',
+    // Intelligence
+    'intelligence/gotchas.yaml',
+    'intelligence/patterns.yaml',
+    'intelligence/confidence.yaml',
+    // Patterns
+    'patterns/elicitation.md',
+    // i18n
+    'i18n/en.yaml',
+    'i18n/pt.yaml',
+    'i18n/es.yaml',
+    'i18n/fr.yaml',
+    // Migrations
+    'migrations/v1.0-to-v1.1.yaml',
+  ];
+
+  for (const file of filesToCopy) {
+    const src = join(FRAMEWORK_SOURCE, file);
+    const dest = join(destDir, file);
+
+    if (existsSync(src)) {
+      createDir(dirname(dest));
+      copyFileSync(src, dest);
+    }
+  }
+}
+
+/**
+ * Configure a specific IDE
+ */
+async function configureIDE(targetDir, ideKey, selectedMCPs) {
+  const config = IDE_CONFIGS[ideKey];
+  if (!config) return;
+
+  // Create config directory
+  createDir(join(targetDir, config.configPath));
+
+  if (ideKey === 'claude-code') {
+    // Thin router
+    const routerContent = `---
+# chati.dev Thin Router
+# This file delegates to the full orchestrator at chati.dev/orchestrator/chati.md
+# DO NOT add logic here -- pure delegation only
+---
+
+Read and execute the orchestrator at \`chati.dev/orchestrator/chati.md\`.
+
+Pass through all context: session (.chati/session.yaml), handoffs (chati.dev/artifacts/handoffs/),
+artifacts (chati.dev/artifacts/), constitution (chati.dev/constitution.md).
+
+This is a thin router. All logic lives in the orchestrator.
+`;
+    writeFileSync(join(targetDir, '.claude', 'commands', 'chati.md'), routerContent, 'utf-8');
+
+    // MCP config
+    if (selectedMCPs.length > 0) {
+      const mcpConfig = generateClaudeMCPConfig(selectedMCPs);
+      writeFileSync(
+        join(targetDir, '.claude', 'mcp.json'),
+        JSON.stringify(mcpConfig, null, 2) + '\n',
+        'utf-8'
+      );
+    }
+  } else {
+    // For other IDEs, create a rules file pointing to chati.dev/
+    const rulesContent = `# chati.dev Framework Rules
+# This file configures ${config.name} to work with chati.dev
+
+## Framework Location
+All framework content is in the \`chati.dev/\` directory.
+
+## Session State
+Runtime session state is in \`.chati/session.yaml\` (IDE-agnostic).
+
+## Getting Started
+The orchestrator is at \`chati.dev/orchestrator/chati.md\`.
+Read it to understand routing, session management, and agent activation.
+
+## Constitution
+Governance rules are in \`chati.dev/constitution.md\` (10 Articles).
+
+## Agents
+- CLARITY: chati.dev/agents/clarity/ (8 agents)
+- Quality: chati.dev/agents/quality/ (2 agents)
+- BUILD: chati.dev/agents/build/ (1 agent)
+- DEPLOY: chati.dev/agents/deploy/ (1 agent)
+`;
+    if (config.rulesFile) {
+      createDir(dirname(join(targetDir, config.rulesFile)));
+      writeFileSync(join(targetDir, config.rulesFile), rulesContent, 'utf-8');
+    }
+  }
+}
+
+/**
+ * Recursively create directory if it doesn't exist
+ */
+function createDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}

package/src/installer/templates.js

@@ -0,0 +1,97 @@
+import yaml from 'js-yaml';
+
+/**
+ * Generate session.yaml content
+ */
+export function generateSessionYaml(config) {
+  const { projectName, projectType, language, selectedIDEs, selectedMCPs } = config;
+
+  const session = {
+    project: {
+      name: projectName,
+      type: projectType,
+      state: 'clarity',
+    },
+    execution_mode: 'interactive',
+    current_agent: '',
+    language: language,
+    ides: selectedIDEs,
+    mcps: selectedMCPs,
+    user_level: 'auto',
+    user_level_confidence: 0.0,
+    agents: {},
+    backlog: [],
+    last_handoff: '',
+    deviations: [],
+  };
+
+  // Initialize all 12 agent statuses
+  const agentNames = [
+    'greenfield-wu', 'brownfield-wu', 'brief', 'detail',
+    'architect', 'ux', 'phases', 'tasks',
+    'qa-planning', 'dev', 'qa-implementation', 'devops',
+  ];
+
+  for (const agent of agentNames) {
+    session.agents[agent] = {
+      status: 'pending',
+      score: 0,
+      criteria_count: 0,
+      completed_at: null,
+    };
+  }
+
+  return yaml.dump(session, { lineWidth: -1, quotingType: '"', forceQuotes: false });
+}
+
+/**
+ * Generate config.yaml content
+ */
+export function generateConfigYaml(config) {
+  const { version, projectType, language, selectedIDEs } = config;
+
+  const configData = {
+    version: version,
+    installed_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    installer_version: version,
+    project_type: projectType,
+    language: language,
+    ides: selectedIDEs,
+  };
+
+  return yaml.dump(configData, { lineWidth: -1, quotingType: '"', forceQuotes: false });
+}
+
+/**
+ * Generate CLAUDE.md content
+ */
+export function generateClaudeMd(config) {
+  const { projectName, projectType, language } = config;
+
+  return `# ${projectName}
+
+## 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.
+
+## 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
+
+## Recent Decisions
+_No decisions yet. Start with /chati._
+
+---
+_Auto-updated by chati.dev agents (Protocol 5.4)_
+`;
+}

package/src/installer/validator.js

@@ -0,0 +1,114 @@
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Validate chati.dev installation
+ * Checks all 13 agents, constitution, session, schemas, etc.
+ */
+export async function validateInstallation(targetDir) {
+  const results = {
+    agents: { pass: false, details: [] },
+    constitution: { pass: false, details: [] },
+    session: { pass: false, details: [] },
+    schemas: { pass: false, details: [] },
+    workflows: { pass: false, details: [] },
+    templates: { pass: false, details: [] },
+    total: 0,
+    passed: 0,
+  };
+
+  // Check all 13 agents (orchestrator + 12 specialized)
+  const agentFiles = [
+    'orchestrator/chati.md',
+    'agents/clarity/greenfield-wu.md',
+    'agents/clarity/brownfield-wu.md',
+    'agents/clarity/brief.md',
+    'agents/clarity/detail.md',
+    'agents/clarity/architect.md',
+    'agents/clarity/ux.md',
+    'agents/clarity/phases.md',
+    'agents/clarity/tasks.md',
+    'agents/quality/qa-planning.md',
+    'agents/quality/qa-implementation.md',
+    'agents/build/dev.md',
+    'agents/deploy/devops.md',
+  ];
+
+  let agentCount = 0;
+  for (const file of agentFiles) {
+    const filePath = join(targetDir, 'chati.dev', file);
+    if (existsSync(filePath)) {
+      const content = readFileSync(filePath, 'utf-8');
+      // Check that agent implements protocols (look for key protocol references)
+      const hasProtocols = content.includes('Protocol') || content.includes('protocol');
+      agentCount++;
+      results.agents.details.push({ file, exists: true, hasProtocols });
+    } else {
+      results.agents.details.push({ file, exists: false, hasProtocols: false });
+    }
+  }
+  results.agents.pass = agentCount === 13;
+  results.total += 1;
+  if (results.agents.pass) results.passed += 1;
+
+  // Check constitution
+  const constitutionPath = join(targetDir, 'chati.dev', 'constitution.md');
+  if (existsSync(constitutionPath)) {
+    const content = readFileSync(constitutionPath, 'utf-8');
+    const articleCount = (content.match(/^## Article/gm) || []).length;
+    results.constitution.pass = articleCount >= 10;
+    results.constitution.details.push({ articleCount });
+  }
+  results.total += 1;
+  if (results.constitution.pass) results.passed += 1;
+
+  // Check session.yaml
+  const sessionPath = join(targetDir, '.chati', 'session.yaml');
+  results.session.pass = existsSync(sessionPath);
+  results.total += 1;
+  if (results.session.pass) results.passed += 1;
+
+  // Check schemas
+  const schemaFiles = ['session.schema.json', 'config.schema.json', 'task.schema.json'];
+  let schemaCount = 0;
+  for (const file of schemaFiles) {
+    if (existsSync(join(targetDir, 'chati.dev', 'schemas', file))) {
+      schemaCount++;
+    }
+  }
+  results.schemas.pass = schemaCount === 3;
+  results.total += 1;
+  if (results.schemas.pass) results.passed += 1;
+
+  // Check workflows
+  const workflowFiles = [
+    'greenfield-fullstack.yaml', 'brownfield-fullstack.yaml',
+    'brownfield-discovery.yaml', 'brownfield-service.yaml', 'brownfield-ui.yaml',
+  ];
+  let workflowCount = 0;
+  for (const file of workflowFiles) {
+    if (existsSync(join(targetDir, 'chati.dev', 'workflows', file))) {
+      workflowCount++;
+    }
+  }
+  results.workflows.pass = workflowCount === 5;
+  results.total += 1;
+  if (results.workflows.pass) results.passed += 1;
+
+  // Check templates
+  const templateFiles = [
+    'prd-tmpl.yaml', 'brownfield-prd-tmpl.yaml',
+    'fullstack-architecture-tmpl.yaml', 'task-tmpl.yaml', 'qa-gate-tmpl.yaml',
+  ];
+  let templateCount = 0;
+  for (const file of templateFiles) {
+    if (existsSync(join(targetDir, 'chati.dev', 'templates', file))) {
+      templateCount++;
+    }
+  }
+  results.templates.pass = templateCount === 5;
+  results.total += 1;
+  if (results.templates.pass) results.passed += 1;
+
+  return results;
+}

package/src/upgrade/backup.js

@@ -0,0 +1,107 @@
+import { existsSync, mkdirSync, cpSync, rmSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Create backup of chati.dev/ directory before upgrade
+ * Backup location: chati.dev/.backup-v{version}/
+ */
+export function createBackup(targetDir, currentVersion) {
+  const frameworkDir = join(targetDir, 'chati.dev');
+  const backupDir = join(frameworkDir, `.backup-v${currentVersion}`);
+
+  if (existsSync(backupDir)) {
+    // Remove old backup of same version
+    rmSync(backupDir, { recursive: true, force: true });
+  }
+
+  mkdirSync(backupDir, { recursive: true });
+
+  // Backup framework files (NOT artifacts or intelligence)
+  const dirsToBackup = [
+    'orchestrator',
+    'agents',
+    'templates',
+    'workflows',
+    'quality-gates',
+    'schemas',
+    'frameworks',
+    'i18n',
+    'patterns',
+    'migrations',
+  ];
+
+  const filesToBackup = [
+    'constitution.md',
+    'config.yaml',
+  ];
+
+  for (const dir of dirsToBackup) {
+    const src = join(frameworkDir, dir);
+    const dest = join(backupDir, dir);
+    if (existsSync(src)) {
+      cpSync(src, dest, { recursive: true });
+    }
+  }
+
+  for (const file of filesToBackup) {
+    const src = join(frameworkDir, file);
+    const dest = join(backupDir, file);
+    if (existsSync(src)) {
+      cpSync(src, dest);
+    }
+  }
+
+  return backupDir;
+}
+
+/**
+ * Restore from backup (rollback)
+ */
+export function restoreFromBackup(targetDir, version) {
+  const frameworkDir = join(targetDir, 'chati.dev');
+  const backupDir = join(frameworkDir, `.backup-v${version}`);
+
+  if (!existsSync(backupDir)) {
+    throw new Error(`Backup not found: ${backupDir}`);
+  }
+
+  // Restore backed-up directories
+  const dirsToRestore = [
+    'orchestrator',
+    'agents',
+    'templates',
+    'workflows',
+    'quality-gates',
+    'schemas',
+    'frameworks',
+    'i18n',
+    'patterns',
+    'migrations',
+  ];
+
+  const filesToRestore = [
+    'constitution.md',
+    'config.yaml',
+  ];
+
+  for (const dir of dirsToRestore) {
+    const src = join(backupDir, dir);
+    const dest = join(frameworkDir, dir);
+    if (existsSync(src)) {
+      if (existsSync(dest)) {
+        rmSync(dest, { recursive: true, force: true });
+      }
+      cpSync(src, dest, { recursive: true });
+    }
+  }
+
+  for (const file of filesToRestore) {
+    const src = join(backupDir, file);
+    const dest = join(frameworkDir, file);
+    if (existsSync(src)) {
+      cpSync(src, dest);
+    }
+  }
+
+  return true;
+}

package/src/upgrade/checker.js

@@ -0,0 +1,105 @@
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import yaml from 'js-yaml';
+import semver from 'semver';
+
+/**
+ * Read current installed version from config.yaml
+ */
+export function getCurrentVersion(targetDir) {
+  const configPath = join(targetDir, 'chati.dev', 'config.yaml');
+  if (!existsSync(configPath)) return null;
+
+  try {
+    const config = yaml.load(readFileSync(configPath, 'utf-8'));
+    return config?.version || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check for available updates
+ * In v1, this compares against the CLI package version
+ * Future versions will query npm registry or GitHub releases
+ */
+export async function checkForUpdate(targetDir, cliVersion) {
+  const currentVersion = getCurrentVersion(targetDir);
+
+  if (!currentVersion) {
+    return {
+      hasUpdate: false,
+      error: 'Could not read current version from chati.dev/config.yaml',
+    };
+  }
+
+  if (!semver.valid(currentVersion)) {
+    return {
+      hasUpdate: false,
+      error: `Invalid version in config.yaml: ${currentVersion}`,
+    };
+  }
+
+  const latestVersion = cliVersion; // In v1, latest = CLI version
+
+  if (semver.gt(latestVersion, currentVersion)) {
+    return {
+      hasUpdate: true,
+      currentVersion,
+      latestVersion,
+      changes: getChangelog(currentVersion, latestVersion),
+    };
+  }
+
+  return {
+    hasUpdate: false,
+    currentVersion,
+    latestVersion,
+    message: 'You are on the latest version.',
+  };
+}
+
+/**
+ * Get changelog between versions
+ * In v1, returns placeholder. Future: read from CHANGELOG.md or API
+ */
+function getChangelog(fromVersion, toVersion) {
+  return [
+    `Changes from v${fromVersion} to v${toVersion}:`,
+    '  Check release notes for details.',
+  ];
+}
+
+/**
+ * Update config.yaml with the new version after successful upgrade
+ */
+export function updateConfigVersion(targetDir, newVersion) {
+  const configPath = join(targetDir, 'chati.dev', 'config.yaml');
+  if (!existsSync(configPath)) return false;
+
+  try {
+    const config = yaml.load(readFileSync(configPath, 'utf-8'));
+    config.version = newVersion;
+    writeFileSync(configPath, yaml.dump(config, { lineWidth: -1 }), 'utf-8');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Compare two versions
+ */
+export function compareVersions(current, target) {
+  if (!semver.valid(current) || !semver.valid(target)) {
+    return { valid: false, error: 'Invalid version format' };
+  }
+
+  return {
+    valid: true,
+    isUpgrade: semver.gt(target, current),
+    isDowngrade: semver.lt(target, current),
+    isSame: semver.eq(target, current),
+    diff: semver.diff(target, current), // 'major', 'minor', 'patch'
+  };
+}