chati-dev 3.2.5 → 3.3.1

package/src/autonomy/worktree-manager.js

@@ -0,0 +1,245 @@
+/**
+ * @fileoverview Git worktree isolation for build loop retries.
+ *
+ * Each retry attempt can optionally run in an isolated git worktree,
+ * preventing failed attempts from corrupting the main working directory.
+ *
+ * Constitution Article XVII — Execution Mode Governance.
+ */
+
+/**
+ * @deprecated Not currently imported by any production module.
+ * Retained for potential future integration. Remove if still unused by v4.0.
+ */
+
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, readdirSync, statSync, rmSync } from 'fs';
+import { join, resolve } from 'path';
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/** Directory for worktrees inside .chati/ */
+const WORKTREE_DIR = '.chati/worktrees';
+
+/** Maximum age (ms) before a worktree is considered stale (24h). */
+const MAX_WORKTREE_AGE_MS = 24 * 60 * 60 * 1000;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Execute a git command in a given directory and return trimmed stdout.
+ *
+ * @param {string} cmd - Git command (without the `git` prefix)
+ * @param {string} cwd - Working directory
+ * @returns {string} Trimmed stdout
+ */
+function git(cmd, cwd) {
+  return execSync(`git ${cmd}`, {
+    cwd,
+    encoding: 'utf-8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+  }).trim();
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Check if a directory is inside a git repository.
+ *
+ * @param {string} dir - Directory path
+ * @returns {boolean}
+ */
+export function isGitRepo(dir) {
+  try {
+    git('rev-parse --is-inside-work-tree', dir);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Create an isolated git worktree for a retry attempt.
+ *
+ * The worktree is placed at `.chati/worktrees/<taskId>-attempt-<N>`.
+ * A new branch is created from the current HEAD.
+ *
+ * @param {string} projectDir - Root project directory
+ * @param {string} taskId - Task identifier
+ * @param {number} attempt - Attempt number
+ * @returns {{ path: string, branch: string, cleanup: () => void }}
+ * @throws {Error} If not a git repo or worktree creation fails
+ */
+export function createWorktree(projectDir, taskId, attempt) {
+  const absProject = resolve(projectDir);
+
+  if (!isGitRepo(absProject)) {
+    throw new Error(`Not a git repository: ${absProject}`);
+  }
+
+  const safeName = `${taskId}-attempt-${attempt}`.replace(/[^a-zA-Z0-9._-]/g, '_');
+  const worktreeBase = join(absProject, WORKTREE_DIR);
+  const worktreePath = join(worktreeBase, safeName);
+  const branch = `chati/${safeName}`;
+
+  // Ensure worktree base directory exists
+  mkdirSync(worktreeBase, { recursive: true });
+
+  // Clean up if a worktree already exists at this path
+  if (existsSync(worktreePath)) {
+    try {
+      git(`worktree remove "${worktreePath}" --force`, absProject);
+    } catch {
+      rmSync(worktreePath, { recursive: true, force: true });
+    }
+  }
+
+  // Delete branch if it exists from a previous run
+  try {
+    git(`branch -D "${branch}"`, absProject);
+  } catch {
+    // Branch doesn't exist — fine
+  }
+
+  // Create worktree with new branch from HEAD
+  git(`worktree add -b "${branch}" "${worktreePath}"`, absProject);
+
+  const cleanup = () => {
+    try {
+      git(`worktree remove "${worktreePath}" --force`, absProject);
+    } catch {
+      // Worktree already removed — ignore
+    }
+    try {
+      git(`branch -D "${branch}"`, absProject);
+    } catch {
+      // Branch already deleted — ignore
+    }
+  };
+
+  return { path: worktreePath, branch, cleanup };
+}
+
+/**
+ * Merge changes from a worktree branch back to the main branch.
+ *
+ * @param {string} projectDir - Root project directory
+ * @param {string} worktreeBranch - Worktree branch name
+ * @param {string} [mainBranch] - Target branch (auto-detected if omitted)
+ * @returns {{ success: boolean, conflicts: string[] }}
+ */
+export function mergeWorktree(projectDir, worktreeBranch, mainBranch) {
+  const absProject = resolve(projectDir);
+
+  // Auto-detect main branch if not specified
+  if (!mainBranch) {
+    try {
+      mainBranch = git('rev-parse --abbrev-ref HEAD', absProject);
+    } catch {
+      mainBranch = 'main';
+    }
+  }
+
+  // Ensure we're on the main branch
+  try {
+    git(`checkout "${mainBranch}"`, absProject);
+  } catch {
+    return { success: false, conflicts: [`Failed to checkout ${mainBranch}`] };
+  }
+
+  // Attempt merge
+  try {
+    git(`merge "${worktreeBranch}" --no-edit`, absProject);
+    return { success: true, conflicts: [] };
+  } catch (err) {
+    // Parse conflicts from error output
+    const conflicts = [];
+    try {
+      const status = git('diff --name-only --diff-filter=U', absProject);
+      if (status) {
+        conflicts.push(...status.split('\n').filter(Boolean));
+      }
+    } catch {
+      conflicts.push('Unknown conflict — check git status');
+    }
+
+    // Abort the failed merge
+    try {
+      git('merge --abort', absProject);
+    } catch {
+      // Already aborted or not in merging state
+    }
+
+    return { success: false, conflicts };
+  }
+}
+
+/**
+ * Clean up stale worktrees that exceed the maximum age.
+ *
+ * @param {string} projectDir - Root project directory
+ * @param {{ maxAge?: number }} [options={}]
+ * @returns {{ cleaned: string[], errors: string[] }}
+ */
+export function cleanupWorktrees(projectDir, options = {}) {
+  const absProject = resolve(projectDir);
+  const maxAge = options.maxAge || MAX_WORKTREE_AGE_MS;
+  const worktreeBase = join(absProject, WORKTREE_DIR);
+  const cleaned = [];
+  const errors = [];
+
+  if (!existsSync(worktreeBase)) {
+    return { cleaned, errors };
+  }
+
+  const now = Date.now();
+  let entries;
+  try {
+    entries = readdirSync(worktreeBase);
+  } catch {
+    return { cleaned, errors: ['Failed to read worktree directory'] };
+  }
+
+  for (const entry of entries) {
+    const entryPath = join(worktreeBase, entry);
+
+    try {
+      const stat = statSync(entryPath);
+      if (!stat.isDirectory()) continue;
+
+      const age = now - stat.mtimeMs;
+      if (age > maxAge) {
+        try {
+          git(`worktree remove "${entryPath}" --force`, absProject);
+        } catch {
+          rmSync(entryPath, { recursive: true, force: true });
+        }
+
+        // Also remove the branch
+        const branch = `chati/${entry}`;
+        try {
+          git(`branch -D "${branch}"`, absProject);
+        } catch {
+          // Branch already deleted
+        }
+
+        cleaned.push(entry);
+      }
+    } catch (err) {
+      errors.push(`${entry}: ${err.message}`);
+    }
+  }
+
+  return { cleaned, errors };
+}
+
+/**
+ * Exported constants for testing.
+ */
+export { WORKTREE_DIR, MAX_WORKTREE_AGE_MS };

package/src/config/agent-customizer.js

@@ -0,0 +1,227 @@
+/**
+ * @fileoverview Agent customization via per-project override files.
+ *
+ * Loads `.customize.yaml` files from `chati.dev/customize/<agent>.yaml`
+ * and applies overrides to agent prompts.
+ *
+ * Constitution Article XVI — Model Governance.
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import yaml from 'js-yaml';
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/** Directory relative to project root where customization files are stored. */
+const CUSTOMIZE_DIR = 'chati.dev/customize';
+
+/** Valid override fields that customizations can set. */
+export const VALID_OVERRIDE_FIELDS = [
+  'model',
+  'extra_context',
+  'skip_sections',
+  'add_sections',
+  'provider',
+  'timeout',
+  'max_iterations',
+];
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * @typedef {object} Customization
+ * @property {boolean} found - Whether a customization file was found
+ * @property {string} [model] - Override model name
+ * @property {string} [extra_context] - Additional context to inject
+ * @property {string[]} [skip_sections] - Sections to omit from prompt
+ * @property {{ name: string, content: string }[]} [add_sections] - Sections to append
+ * @property {string} [provider] - Override provider name
+ * @property {number} [timeout] - Override timeout in ms
+ * @property {number} [max_iterations] - Override max iterations
+ */
+
+/**
+ * Load customization for a specific agent.
+ *
+ * @param {string} projectDir - Project root directory
+ * @param {string} agentName - Agent name (e.g., 'brief', 'dev')
+ * @returns {{ found: boolean, overrides: Customization }}
+ */
+export function loadCustomization(projectDir, agentName) {
+  if (!projectDir || !agentName) {
+    return { found: false, overrides: {} };
+  }
+
+  const customizePath = join(projectDir, CUSTOMIZE_DIR, `${agentName}.yaml`);
+
+  if (!existsSync(customizePath)) {
+    return { found: false, overrides: {} };
+  }
+
+  try {
+    const raw = readFileSync(customizePath, 'utf-8');
+    const parsed = yaml.load(raw);
+
+    if (!parsed || typeof parsed !== 'object') {
+      return { found: true, overrides: {} };
+    }
+
+    // Filter to valid override fields only
+    const overrides = {};
+    for (const field of VALID_OVERRIDE_FIELDS) {
+      if (parsed[field] !== undefined) {
+        overrides[field] = parsed[field];
+      }
+    }
+
+    return { found: true, overrides };
+  } catch {
+    return { found: false, overrides: {} };
+  }
+}
+
+/**
+ * Apply customization overrides to an agent prompt.
+ *
+ * @param {string} agentPrompt - Original agent prompt
+ * @param {Customization} customization - Customization overrides
+ * @returns {string} Modified prompt
+ */
+export function applyCustomization(agentPrompt, customization) {
+  if (!agentPrompt || !customization) {
+    return agentPrompt || '';
+  }
+
+  let prompt = agentPrompt;
+
+  // Skip sections
+  if (customization.skip_sections && Array.isArray(customization.skip_sections)) {
+    for (const sectionName of customization.skip_sections) {
+      // Match section heading + all content until the next heading of same or higher level, or end of text
+      const pattern = new RegExp(
+        `^#{1,3}\\s+${escapeRegex(sectionName)}\\s*\\n[\\s\\S]*?(?=\\n#{1,3}\\s|\\Z)`,
+        'gm'
+      );
+      // \\Z is not JS — use two-pass: try lookahead for next heading, then fallback to end
+      const headingPattern = new RegExp(
+        `^(#{1,3})\\s+${escapeRegex(sectionName)}[^\\n]*\\n([\\s\\S]*?)(?=^#{1,3}\\s)`,
+        'gm'
+      );
+      let replaced = prompt.replace(headingPattern, '');
+      if (replaced === prompt) {
+        // Section is at the end — no next heading follows
+        const endPattern = new RegExp(
+          `^(#{1,3})\\s+${escapeRegex(sectionName)}[^\\n]*\\n[\\s\\S]*$`,
+          'gm'
+        );
+        replaced = prompt.replace(endPattern, '');
+      }
+      prompt = replaced;
+    }
+  }
+
+  // Add extra context at the end
+  if (customization.extra_context && typeof customization.extra_context === 'string') {
+    prompt += `\n\n---\n\n## Additional Context\n\n${customization.extra_context}\n`;
+  }
+
+  // Add new sections
+  if (customization.add_sections && Array.isArray(customization.add_sections)) {
+    for (const section of customization.add_sections) {
+      if (section.name && section.content) {
+        prompt += `\n\n## ${section.name}\n\n${section.content}\n`;
+      }
+    }
+  }
+
+  return prompt;
+}
+
+/**
+ * Validate a customization object.
+ *
+ * @param {object} customization
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+export function validateCustomization(customization) {
+  const errors = [];
+
+  if (!customization || typeof customization !== 'object') {
+    errors.push('Customization must be a non-null object');
+    return { valid: false, errors };
+  }
+
+  // Check for unknown fields
+  for (const key of Object.keys(customization)) {
+    if (!VALID_OVERRIDE_FIELDS.includes(key)) {
+      errors.push(`Unknown override field: "${key}"`);
+    }
+  }
+
+  // Validate model
+  if (customization.model !== undefined && typeof customization.model !== 'string') {
+    errors.push('model must be a string');
+  }
+
+  // Validate extra_context
+  if (customization.extra_context !== undefined && typeof customization.extra_context !== 'string') {
+    errors.push('extra_context must be a string');
+  }
+
+  // Validate skip_sections
+  if (customization.skip_sections !== undefined) {
+    if (!Array.isArray(customization.skip_sections)) {
+      errors.push('skip_sections must be an array');
+    } else if (customization.skip_sections.some(s => typeof s !== 'string')) {
+      errors.push('skip_sections must contain only strings');
+    }
+  }
+
+  // Validate add_sections
+  if (customization.add_sections !== undefined) {
+    if (!Array.isArray(customization.add_sections)) {
+      errors.push('add_sections must be an array');
+    } else {
+      for (const section of customization.add_sections) {
+        if (!section.name || !section.content) {
+          errors.push('Each add_section must have name and content');
+        }
+      }
+    }
+  }
+
+  // Validate timeout
+  if (customization.timeout !== undefined) {
+    if (typeof customization.timeout !== 'number' || customization.timeout <= 0) {
+      errors.push('timeout must be a positive number');
+    }
+  }
+
+  // Validate max_iterations
+  if (customization.max_iterations !== undefined) {
+    if (typeof customization.max_iterations !== 'number' || customization.max_iterations <= 0) {
+      errors.push('max_iterations must be a positive number');
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Escape special regex characters in a string.
+ *
+ * @param {string} str
+ * @returns {string}
+ */
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/config/ide-configs.js

@@ -1,68 +1,98 @@
 /**
- * IDE Configuration Mapping (5 IDEs)
+ * IDE Configuration Mapping (7 IDEs)
  * Defines where chati.dev agents are deployed per IDE
  */
 export const IDE_CONFIGS = {
   'claude-code': {
     name: 'Claude Code',
     description: 'Anthropic official CLI',
+    group: 'cli',
     recommended: true,
     configPath: '.claude/commands/',
     rulesFile: '.claude/CLAUDE.md',
     mcpConfigFile: '.claude/mcp.json',
     formatNotes: 'Native markdown format',
   },
+  'gemini-cli': {
+    name: 'Gemini CLI',
+    description: 'Google AI terminal agent',
+    group: 'cli',
+    recommended: false,
+    configPath: '.gemini/commands/',
+    rulesFile: 'GEMINI.md',
+    mcpConfigFile: '.gemini/settings.json',
+    formatNotes: 'TOML command format',
+    contextPath: '.gemini/context/',
+    hooksPath: '.gemini/hooks/',
+  },
+  'codex-cli': {
+    name: 'Codex CLI',
+    description: 'OpenAI Codex terminal agent',
+    group: 'cli',
+    recommended: false,
+    configPath: '.agents/skills/chati/',
+    rulesFile: 'AGENTS.md',
+    mcpConfigFile: null,
+    formatNotes: 'Codex skill format (SKILL.md with YAML frontmatter)',
+    rulesPath: '.codex/rules/',
+    overrideFile: 'AGENTS.override.md',
+  },
   'vscode': {
     name: 'VS Code',
     description: 'Extensions: Continue, Copilot Chat, etc',
+    group: 'editor',
     recommended: false,
     configPath: '.vscode/chati/',
     rulesFile: '.vscode/chati/rules.md',
     mcpConfigFile: null,
     formatNotes: 'Markdown with VS Code extension support',
   },
-  'antigravity': {
-    name: 'AntiGravity',
-    description: 'Google agentic development platform',
-    recommended: false,
-    configPath: '.antigravity/agents/',
-    rulesFile: '.antigravity/rules.md',
-    mcpConfigFile: null,
-    formatNotes: 'Google platform format',
-  },
   'cursor': {
     name: 'Cursor',
     description: 'AI-first code editor',
+    group: 'editor',
     recommended: false,
     configPath: '.cursor/rules/',
     rulesFile: '.cursorrules',
     mcpConfigFile: null,
     formatNotes: 'Cursor rules format',
   },
-  'codex-cli': {
-    name: 'Codex CLI',
-    description: 'OpenAI Codex terminal agent',
+  'windsurf': {
+    name: 'Windsurf',
+    description: 'AI-powered code editor by Codeium',
+    group: 'editor',
     recommended: false,
-    configPath: '.agents/skills/chati/',
-    rulesFile: 'AGENTS.md',
+    configPath: '.windsurf/rules/',
+    rulesFile: '.windsurfrules',
     mcpConfigFile: null,
-    formatNotes: 'Codex skill format (SKILL.md with YAML frontmatter)',
-    rulesPath: '.codex/rules/',
-    overrideFile: 'AGENTS.override.md',
+    formatNotes: 'Windsurf rules format (markdown)',
   },
-  'gemini-cli': {
-    name: 'Gemini CLI',
-    description: 'Google AI terminal agent',
+  'antigravity': {
+    name: 'AntiGravity',
+    description: 'Google agentic development platform',
+    group: 'editor',
     recommended: false,
-    configPath: '.gemini/commands/',
-    rulesFile: 'GEMINI.md',
-    mcpConfigFile: '.gemini/settings.json',
-    formatNotes: 'TOML command format',
-    contextPath: '.gemini/context/',
-    hooksPath: '.gemini/hooks/',
+    configPath: '.antigravity/agents/',
+    rulesFile: '.antigravity/rules.md',
+    mcpConfigFile: null,
+    formatNotes: 'Google platform format',
   },
 };
 
+/**
+ * Map IDE key to its CLI provider name.
+ * Editor-based IDEs (vscode, cursor, windsurf, antigravity) don't have a CLI provider.
+ */
+export const IDE_TO_PROVIDER = {
+  'claude-code': 'claude',
+  'gemini-cli': 'gemini',
+  'codex-cli': 'codex',
+  'vscode': null,
+  'cursor': null,
+  'windsurf': null,
+  'antigravity': null,
+};
+
 /**
  * Get list of IDEs for selection prompt
  */