chati-dev 1.0.0

package/src/upgrade/migrator.js

@@ -0,0 +1,171 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
+import { join } from 'path';
+import yaml from 'js-yaml';
+import semver from 'semver';
+
+/**
+ * Find applicable migrations between two versions
+ */
+export function findMigrations(targetDir, fromVersion, toVersion) {
+  const migrationsDir = join(targetDir, 'chati.dev', 'migrations');
+  if (!existsSync(migrationsDir)) return [];
+
+  const files = readdirSync(migrationsDir)
+    .filter(f => f.endsWith('.yaml'))
+    .sort();
+
+  const applicable = [];
+
+  for (const file of files) {
+    try {
+      const content = yaml.load(readFileSync(join(migrationsDir, file), 'utf-8'));
+      const migration = content?.migration;
+
+      if (!migration?.from || !migration?.to) continue;
+
+      // Check if this migration is in the upgrade path
+      if (
+        semver.gte(migration.from, fromVersion) &&
+        semver.lte(migration.to, toVersion)
+      ) {
+        applicable.push({
+          file,
+          from: migration.from,
+          to: migration.to,
+          description: migration.description || '',
+          breaking: migration.breaking || false,
+          steps: content.steps || [],
+          rollback: content.rollback || [],
+        });
+      }
+    } catch {
+      // Skip invalid migration files
+    }
+  }
+
+  // Sort by target version
+  applicable.sort((a, b) => semver.compare(a.to, b.to));
+
+  return applicable;
+}
+
+/**
+ * Execute a single migration step
+ */
+function executeMigrationStep(targetDir, step) {
+  switch (step.type) {
+    case 'create_directory': {
+      const dir = join(targetDir, step.path);
+      if (!existsSync(dir) || !step.idempotent) {
+        mkdirSync(dir, { recursive: true });
+      }
+      break;
+    }
+
+    case 'create_file': {
+      const filePath = join(targetDir, step.path);
+      if (!existsSync(filePath) || !step.skip_if_exists) {
+        mkdirSync(join(targetDir, step.path, '..'), { recursive: true });
+        writeFileSync(filePath, step.content || '', 'utf-8');
+      }
+      break;
+    }
+
+    case 'update_yaml': {
+      const filePath = join(targetDir, step.path);
+      if (!existsSync(filePath)) break;
+
+      const content = yaml.load(readFileSync(filePath, 'utf-8')) || {};
+
+      if (step.operation === 'add_field') {
+        const keys = step.field.split('.');
+        let obj = content;
+        for (let i = 0; i < keys.length - 1; i++) {
+          if (!obj[keys[i]]) obj[keys[i]] = {};
+          obj = obj[keys[i]];
+        }
+        const lastKey = keys[keys.length - 1];
+        if (!step.skip_if_exists || !(lastKey in obj)) {
+          obj[lastKey] = step.default;
+        }
+      } else if (step.operation === 'set') {
+        const keys = step.field.split('.');
+        let obj = content;
+        for (let i = 0; i < keys.length - 1; i++) {
+          if (!obj[keys[i]]) obj[keys[i]] = {};
+          obj = obj[keys[i]];
+        }
+        obj[keys[keys.length - 1]] = step.value;
+      }
+
+      writeFileSync(filePath, yaml.dump(content, { lineWidth: -1 }), 'utf-8');
+      break;
+    }
+
+    case 'delete_directory': {
+      const dir = join(targetDir, step.path);
+      if (existsSync(dir)) {
+        if (step.only_if_empty) {
+          const files = readdirSync(dir);
+          if (files.length === 0) {
+            rmSync(dir, { recursive: true });
+          }
+        } else {
+          rmSync(dir, { recursive: true });
+        }
+      }
+      break;
+    }
+
+    default:
+      // Unknown step type - skip
+      break;
+  }
+}
+
+/**
+ * Run all applicable migrations sequentially
+ */
+export async function runMigrations(targetDir, fromVersion, toVersion) {
+  const migrations = findMigrations(targetDir, fromVersion, toVersion);
+
+  if (migrations.length === 0) {
+    return { success: true, migrationsRun: 0 };
+  }
+
+  const results = [];
+
+  for (const migration of migrations) {
+    try {
+      for (const step of migration.steps) {
+        executeMigrationStep(targetDir, step);
+      }
+      results.push({ file: migration.file, success: true });
+    } catch (err) {
+      results.push({ file: migration.file, success: false, error: err.message });
+
+      // Attempt rollback for this migration
+      try {
+        for (const step of migration.rollback) {
+          executeMigrationStep(targetDir, step);
+        }
+      } catch {
+        // Rollback failed - return error
+      }
+
+      return {
+        success: false,
+        migrationsRun: results.filter(r => r.success).length,
+        failedAt: migration.file,
+        error: err.message,
+        results,
+      };
+    }
+  }
+
+  return {
+    success: true,
+    migrationsRun: migrations.length,
+    results,
+  };
+}

package/src/utils/colors.js

@@ -0,0 +1,18 @@
+import chalk from 'chalk';
+
+// chati.dev brand color: steel blue
+export const brand = chalk.hex('#6BA4DC');
+export const dim = chalk.dim;
+export const bold = chalk.bold;
+export const green = chalk.green;
+export const red = chalk.red;
+export const yellow = chalk.yellow;
+export const cyan = chalk.cyan;
+export const gray = chalk.gray;
+export const white = chalk.white;
+
+export const success = chalk.green;
+export const error = chalk.red;
+export const warning = chalk.yellow;
+export const info = chalk.hex('#6BA4DC');
+export const muted = chalk.dim;

package/src/utils/detector.js

@@ -0,0 +1,51 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Auto-detect project type (greenfield vs brownfield)
+ * Brownfield signals: package.json, src/, .git/, etc.
+ */
+export function detectProjectType(targetDir) {
+  const signals = {
+    packageJson: existsSync(join(targetDir, 'package.json')),
+    srcDir: existsSync(join(targetDir, 'src')),
+    gitDir: existsSync(join(targetDir, '.git')),
+    composerJson: existsSync(join(targetDir, 'composer.json')),
+    requirementsTxt: existsSync(join(targetDir, 'requirements.txt')),
+    goMod: existsSync(join(targetDir, 'go.mod')),
+    cargoToml: existsSync(join(targetDir, 'Cargo.toml')),
+    pomXml: existsSync(join(targetDir, 'pom.xml')),
+  };
+
+  const brownfieldSignals = Object.values(signals).filter(Boolean).length;
+
+  return {
+    suggestion: brownfieldSignals >= 2 ? 'brownfield' : 'greenfield',
+    signals,
+    confidence: brownfieldSignals >= 2 ? 'high' : brownfieldSignals === 1 ? 'medium' : 'low',
+  };
+}
+
+/**
+ * Detect currently installed IDEs by checking common paths/commands
+ */
+export function detectInstalledIDEs() {
+  const detected = [];
+
+  // Claude Code - check if claude CLI exists
+  if (existsSync('/usr/local/bin/claude') || existsSync(join(process.env.HOME || '', '.claude'))) {
+    detected.push('claude-code');
+  }
+
+  // VS Code - check .vscode or code command
+  if (existsSync(join(process.env.HOME || '', '.vscode'))) {
+    detected.push('vscode');
+  }
+
+  // Cursor
+  if (existsSync(join(process.env.HOME || '', '.cursor'))) {
+    detected.push('cursor');
+  }
+
+  return detected;
+}

package/src/utils/logger.js

@@ -0,0 +1,41 @@
+import { success, error, warning, info, muted, brand, dim } from './colors.js';
+
+export function logStep(message) {
+  console.log(`  ${success('✓')} ${message}`);
+}
+
+export function logError(message) {
+  console.log(`  ${error('✗')} ${message}`);
+}
+
+export function logWarning(message) {
+  console.log(`  ${warning('⚠')} ${message}`);
+}
+
+export function logInfo(message) {
+  console.log(`  ${info('ℹ')} ${message}`);
+}
+
+export function logMuted(message) {
+  console.log(`  ${muted(message)}`);
+}
+
+export function logBanner(logoText, version) {
+  const lines = logoText.trim().split('\n');
+  for (const line of lines) {
+    console.log(brand(line));
+  }
+  console.log(brand(`chati.dev v${version}`));
+  console.log(dim('AI-Powered Multi-Agent Development Framework'));
+  console.log(dim('═'.repeat(55)));
+  console.log();
+}
+
+export function logSection(title) {
+  console.log();
+  console.log(`  ${brand('──')} ${title} ${brand('─'.repeat(Math.max(0, 45 - title.length)))}`);
+}
+
+export function logResult(label, value) {
+  console.log(`  ${muted(label + ':')}  ${value}`);
+}

package/src/wizard/feedback.js

@@ -0,0 +1,76 @@
+import ora from 'ora';
+import { brand, success, dim } from '../utils/colors.js';
+
+/**
+ * Create a spinner with chati.dev branding
+ */
+export function createSpinner(text) {
+  return ora({
+    text,
+    color: 'cyan',
+    spinner: 'dots',
+  });
+}
+
+/**
+ * Show installation progress step
+ */
+export function showStep(message) {
+  console.log(`  ${success('✓')} ${message}`);
+}
+
+/**
+ * Show validation step
+ */
+export function showValidation(message) {
+  console.log(`  ${success('✓')} ${message}`);
+}
+
+/**
+ * Show warning
+ */
+export function showWarning(message) {
+  console.log(`  ${brand('⚠')} ${message}`);
+}
+
+/**
+ * Show error
+ */
+export function showError(message) {
+  console.log(`  ${'✗'} ${message}`);
+}
+
+/**
+ * Show quick start guide
+ */
+export function showQuickStart(title, steps) {
+  console.log();
+  console.log(`${brand(title)}:`);
+  steps.forEach((step, i) => {
+    console.log(`  ${dim(`${i + 1}.`)} ${step}`);
+  });
+  console.log();
+  console.log(`${dim('Documentation:')} chati.dev/constitution.md`);
+  console.log(`${dim('Session:')}       .chati/session.yaml`);
+}
+
+/**
+ * Show summary table
+ */
+export function showSummary(data) {
+  console.log();
+  for (const [label, value] of Object.entries(data)) {
+    const paddedLabel = label.padEnd(12);
+    console.log(`  ${dim(paddedLabel)} ${value}`);
+  }
+}
+
+/**
+ * Show checklist of items to install
+ */
+export function showChecklist(items) {
+  console.log();
+  for (const item of items) {
+    console.log(`    ${success('✓')} ${item}`);
+  }
+}

package/src/wizard/i18n.js

@@ -0,0 +1,168 @@
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import yaml from 'js-yaml';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Bundled fallback strings (English) for when i18n files aren't available
+const FALLBACK_EN = {
+  installer: {
+    welcome: 'Welcome to chati.dev',
+    select_language: 'Select your language:',
+    project_type: 'What type of project are you setting up?',
+    greenfield: 'Greenfield (new project from scratch)',
+    brownfield: 'Brownfield (existing project integration)',
+    detected_brownfield: 'Detected package.json and src/ in current directory',
+    suggestion_brownfield: 'Suggestion: Brownfield',
+    select_ides: 'Select IDE(s) for chati.dev configuration:',
+    select_mcps: 'Select MCPs to install (project-level):',
+    confirmation_title: 'Installation Summary',
+    project_label: 'Project',
+    language_label: 'Language',
+    ides_label: 'IDEs',
+    mcps_label: 'MCPs',
+    will_install: 'Will install:',
+    agents_count: '13 agent definitions (CLARITY, BUILD, DEPLOY phases)',
+    workflows_count: '5 workflow blueprints',
+    templates_count: '5 templates (PRD, Brownfield PRD, Architecture, Task, QA Gate)',
+    constitution: 'Constitution (10 Articles + Preamble)',
+    session_mgmt: 'Session management system',
+    quality_gates: 'Quality gates (4-tier validation)',
+    proceed: 'Proceed with installation?',
+    installing: 'Installing chati.dev...',
+    created_chati: 'Created .chati/ session directory',
+    created_framework: 'Created chati.dev/ framework directory (agents, templates, workflows)',
+    created_commands: 'Created .claude/commands/ (thin router)',
+    installed_constitution: 'Installed Constitution (Articles I-X)',
+    created_session: 'Created session.yaml schema',
+    created_claude_md: 'Created CLAUDE.md',
+    configured_mcps: 'Configured MCPs:',
+    validating: 'Validating installation...',
+    agents_valid: 'All 13 agents implement 8 protocols',
+    handoff_ok: 'Handoff protocol: OK',
+    validation_ok: 'Self-validation criteria: OK',
+    constitution_ok: 'Constitution: 10 articles verified',
+    session_ok: 'Session schema: valid',
+    success: 'chati.dev installed successfully!',
+    quick_start_title: 'Quick Start',
+    quick_start_1: 'Open your IDE',
+    quick_start_2: 'Type: /chati',
+    quick_start_3: 'The orchestrator will guide you through the process',
+  },
+  agents: {
+    starting: 'Starting agent: {agent}',
+    completed: 'Agent {agent} completed with score {score}%',
+    refining: 'Refining artifacts for consistency...',
+    running_validations: 'Running additional validations...',
+    blocked: 'Blocker detected: {blocker}',
+  },
+  options: {
+    continue: 'Continue with {agent} (Recommended)',
+    review: 'Review last result',
+    status: 'View full status',
+    enter_prompt: 'Enter the number or describe what you want to do:',
+  },
+  status: {
+    project: 'Project',
+    type: 'Type',
+    phase: 'Phase',
+    mode: 'Mode',
+    language: 'Language',
+    ide: 'IDE',
+    current_agent: 'Current Agent',
+    last_handoff: 'Last Handoff',
+    backlog_items: 'Backlog Items',
+    high_priority: 'high priority',
+  },
+  errors: {
+    session_corrupted: 'Session file appears corrupted. Attempting recovery...',
+    handoff_missing: 'Handoff not found. Using session.yaml + CLAUDE.md as fallback.',
+    agent_failed: 'Agent failed after 3 attempts. Escalating to user.',
+    mcp_required: "Required MCP '{mcp}' is not configured. Installation instructions:",
+    mcp_optional: "Optional MCP '{mcp}' not configured. Skipping related functionality.",
+  },
+};
+
+let currentStrings = FALLBACK_EN;
+let currentLanguage = 'en';
+
+/**
+ * Load i18n strings for a given language
+ * Tries: 1) installed chati.dev/i18n/ in target project, 2) bundled assets, 3) fallback
+ */
+export function loadLanguage(lang, targetDir = null) {
+  currentLanguage = lang;
+
+  if (lang === 'en') {
+    currentStrings = FALLBACK_EN;
+    return currentStrings;
+  }
+
+  // Try to load from installed project i18n
+  const paths = [
+    targetDir && join(targetDir, 'chati.dev', 'i18n', `${lang}.yaml`),
+    join(__dirname, '..', '..', 'assets', 'i18n', `${lang}.yaml`),
+  ].filter(Boolean);
+
+  for (const filePath of paths) {
+    if (existsSync(filePath)) {
+      try {
+        const content = readFileSync(filePath, 'utf-8');
+        const parsed = yaml.load(content);
+        currentStrings = parsed;
+        return currentStrings;
+      } catch {
+        // Fall through to next path
+      }
+    }
+  }
+
+  // Fallback to English
+  currentStrings = FALLBACK_EN;
+  return currentStrings;
+}
+
+/**
+ * Get a translated string by dot-notation key
+ * Supports interpolation: t('agents.completed', { agent: 'Brief', score: 97 })
+ */
+export function t(key, vars = {}) {
+  const keys = key.split('.');
+  let value = currentStrings;
+
+  for (const k of keys) {
+    if (value && typeof value === 'object' && k in value) {
+      value = value[k];
+    } else {
+      // Fallback to English
+      value = FALLBACK_EN;
+      for (const fk of keys) {
+        if (value && typeof value === 'object' && fk in value) {
+          value = value[fk];
+        } else {
+          return key; // Return key itself if not found
+        }
+      }
+      break;
+    }
+  }
+
+  if (typeof value !== 'string') return key;
+
+  // Interpolate variables
+  return value.replace(/\{(\w+)\}/g, (_, varName) => {
+    return vars[varName] !== undefined ? String(vars[varName]) : `{${varName}}`;
+  });
+}
+
+export function getCurrentLanguage() {
+  return currentLanguage;
+}
+
+export const SUPPORTED_LANGUAGES = [
+  { value: 'en', label: 'English' },
+  { value: 'pt', label: 'Portugues' },
+  { value: 'es', label: 'Espanol' },
+  { value: 'fr', label: 'Francais' },
+];

package/src/wizard/index.js

@@ -0,0 +1,107 @@
+import * as p from '@clack/prompts';
+import { readFileSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import { fileURLToPath } from 'url';
+import { logBanner } from '../utils/logger.js';
+import { stepLanguage, stepProjectType, stepIDEs, stepMCPs, stepConfirmation } from './questions.js';
+import { createSpinner, showStep, showValidation, showQuickStart } from './feedback.js';
+import { installFramework } from '../installer/core.js';
+import { validateInstallation } from '../installer/validator.js';
+import { t } from './i18n.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const VERSION = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf-8')).version;
+
+/**
+ * Run the 6-step installer wizard
+ */
+export async function runWizard(targetDir, options = {}) {
+  // Load ASCII logo
+  let logoText;
+  try {
+    logoText = readFileSync(join(__dirname, '..', '..', 'assets', 'logo.txt'), 'utf-8');
+  } catch {
+    logoText = 'chati.dev';
+  }
+
+  // Step 1: Logo + Language Selection (in English)
+  logBanner(logoText, VERSION);
+
+  p.intro('Setting up chati.dev');
+
+  const language = options.language || await stepLanguage();
+
+  // Step 2: Project Type
+  const projectType = options.projectType || await stepProjectType(targetDir);
+
+  // Step 3: IDE Selection
+  const selectedIDEs = options.ides || await stepIDEs();
+
+  // Step 4: MCP Selection
+  const selectedMCPs = options.mcps || await stepMCPs(projectType);
+
+  // Step 5: Confirmation
+  const projectName = basename(targetDir);
+  const config = {
+    projectName,
+    projectType,
+    language,
+    selectedIDEs,
+    selectedMCPs,
+    targetDir,
+    version: VERSION,
+  };
+
+  await stepConfirmation(config);
+
+  // Step 6: Installation + Validation
+  console.log();
+  const installSpinner = createSpinner(t('installer.installing'));
+  installSpinner.start();
+
+  try {
+    await installFramework(config);
+    installSpinner.stop();
+
+    showStep(t('installer.created_chati'));
+    showStep(t('installer.created_framework'));
+    showStep(t('installer.created_commands'));
+    showStep(t('installer.installed_constitution'));
+    showStep(t('installer.created_session'));
+    showStep(t('installer.created_claude_md'));
+
+    if (selectedMCPs.length > 0) {
+      showStep(`${t('installer.configured_mcps')} ${selectedMCPs.join(', ')}`);
+    }
+
+    // Validation
+    console.log();
+    const validateSpinner = createSpinner(t('installer.validating'));
+    validateSpinner.start();
+
+    const validation = await validateInstallation(targetDir);
+    validateSpinner.stop();
+
+    showValidation(t('installer.agents_valid'));
+    showValidation(t('installer.handoff_ok'));
+    showValidation(t('installer.validation_ok'));
+    showValidation(t('installer.constitution_ok'));
+    showValidation(t('installer.session_ok'));
+
+    console.log();
+    p.outro(t('installer.success'));
+
+    const primaryIDE = selectedIDEs[0] || 'your IDE';
+    showQuickStart(t('installer.quick_start_title'), [
+      `${t('installer.quick_start_1')} (${primaryIDE})`,
+      t('installer.quick_start_2'),
+      t('installer.quick_start_3'),
+    ]);
+
+    return { success: true, config, validation };
+  } catch (err) {
+    installSpinner.stop();
+    p.cancel(`Installation failed: ${err.message}`);
+    return { success: false, error: err.message };
+  }
+}