@nerviq/cli 0.0.1 → 0.9.0-beta.2

package/src/aider/interactive.js

@@ -0,0 +1,334 @@
+/**
+ * Aider Interactive Wizard — 8-stage guided setup
+ *
+ * Simpler than IDE wizards — no hooks/MCP stages.
+ * Uses Node.js readline (zero dependencies).
+ *
+ * Stages:
+ *   1. Project Detection
+ *   2. Git Safety Posture
+ *   3. Model Configuration
+ *   4. Convention File
+ *   5. Domain Pack Selection
+ *   6. Verification Loop
+ *   7. CI Integration
+ *   8. Review & Generate
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { STACKS } = require('../techniques');
+const { AiderProjectContext } = require('./context');
+const { AIDER_TECHNIQUES } = require('./techniques');
+const { AIDER_DOMAIN_PACKS, detectAiderDomainPacks } = require('./domain-packs');
+const { recommendAiderMcpPacks, AIDER_MCP_PACKS } = require('./mcp-packs');
+const { setupAider } = require('./setup');
+
+const COLORS = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m',
+  blue: '\x1b[36m', magenta: '\x1b[35m',
+};
+const c = (text, color) => `${COLORS[color] || ''}${text}${COLORS.reset}`;
+
+function ask(rl, question) {
+  return new Promise(resolve => rl.question(question, resolve));
+}
+
+function isTTY() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+const STAGE_NAMES = [
+  'Project Detection',
+  'Git Safety Posture',
+  'Model Configuration',
+  'Convention File',
+  'Domain Pack Selection',
+  'Verification Loop',
+  'CI Integration',
+  'Review & Generate',
+];
+
+function printStageHeader(index) {
+  const num = index + 1;
+  const total = STAGE_NAMES.length;
+  console.log('');
+  console.log(c(`  ── Stage ${num}/${total}: ${STAGE_NAMES[index]} ──`, 'magenta'));
+  console.log('');
+}
+
+// --- Stage 1: Project Detection ---
+
+function runProjectDetection(ctx) {
+  const stacks = ctx.detectStacks(STACKS);
+  const hasGit = ctx.hasGitRepo();
+  const hasConfYml = Boolean(ctx.configContent());
+  const hasConventions = ctx.conventionFiles().length > 0;
+
+  return {
+    stacks,
+    hasGit,
+    hasConfYml,
+    hasConventions,
+    projectName: path.basename(ctx.dir),
+  };
+}
+
+// --- Stage 2: Git Safety Posture ---
+
+async function runGitSafety(rl, state) {
+  console.log('  Aider uses git as its ONLY safety mechanism.');
+  console.log('  Auto-commits create an undo trail for every change.');
+  console.log('');
+
+  const autoCommits = await ask(rl, c('  Enable auto-commits? (Y/n): ', 'blue'));
+  state.autoCommits = autoCommits.trim().toLowerCase() !== 'n';
+
+  const attribution = await ask(rl, c('  Enable commit attribution for AI traceability? (Y/n): ', 'blue'));
+  state.attribution = attribution.trim().toLowerCase() !== 'n';
+
+  const commitPrefix = await ask(rl, c('  Commit prefix for AI commits (default: "aider: "): ', 'blue'));
+  state.commitPrefix = commitPrefix.trim() || 'aider: ';
+
+  return 'next';
+}
+
+// --- Stage 3: Model Configuration ---
+
+async function runModelConfig(rl, state) {
+  console.log('  Aider has 3 model roles:');
+  console.log('    - main: does the coding');
+  console.log('    - editor: applies edits to files');
+  console.log('    - weak: generates commit messages (cheapest)');
+  console.log('');
+
+  const mainModel = await ask(rl, c('  Main model (e.g., claude-sonnet-4-20250514, gpt-4o, leave blank for default): ', 'blue'));
+  state.mainModel = mainModel.trim() || null;
+
+  const architect = await ask(rl, c('  Enable architect mode (2-model planning + editing)? (y/N): ', 'blue'));
+  state.architect = architect.trim().toLowerCase() === 'y';
+
+  const cachePrompts = await ask(rl, c('  Enable prompt caching for cost savings? (Y/n): ', 'blue'));
+  state.cachePrompts = cachePrompts.trim().toLowerCase() !== 'n';
+
+  return 'next';
+}
+
+// --- Stage 4: Convention File ---
+
+async function runConventions(rl, state, ctx) {
+  const existing = ctx.conventionFiles();
+  if (existing.length > 0) {
+    console.log(`  Found existing convention files: ${existing.join(', ')}`);
+    const keep = await ask(rl, c('  Keep existing convention files? (Y/n): ', 'blue'));
+    if (keep.trim().toLowerCase() !== 'n') {
+      state.generateConventions = false;
+      return 'next';
+    }
+  }
+
+  console.log('  Aider has NO auto-discovery — convention files must be explicitly passed via read:');
+  const generate = await ask(rl, c('  Generate CONVENTIONS.md? (Y/n): ', 'blue'));
+  state.generateConventions = generate.trim().toLowerCase() !== 'n';
+
+  return 'next';
+}
+
+// --- Stage 5: Domain Pack Selection ---
+
+async function runDomainPacks(rl, state, ctx) {
+  const detected = detectAiderDomainPacks(ctx);
+  console.log('  Detected domain packs:');
+  for (const pack of detected) {
+    console.log(`    - ${pack.label}: ${pack.matchReasons[0] || pack.useWhen}`);
+  }
+  console.log('');
+
+  const accept = await ask(rl, c('  Accept detected domain packs? (Y/n): ', 'blue'));
+  if (accept.trim().toLowerCase() !== 'n') {
+    state.domainPacks = detected.map(p => p.key);
+  } else {
+    console.log('  Available packs:');
+    AIDER_DOMAIN_PACKS.forEach((p, i) => {
+      console.log(`    ${i + 1}. ${p.label} — ${p.useWhen.slice(0, 60)}`);
+    });
+    const choices = await ask(rl, c('  Enter pack numbers (comma-separated): ', 'blue'));
+    const indices = choices.split(',').map(s => parseInt(s.trim(), 10) - 1).filter(i => i >= 0 && i < AIDER_DOMAIN_PACKS.length);
+    state.domainPacks = indices.map(i => AIDER_DOMAIN_PACKS[i].key);
+  }
+
+  return 'next';
+}
+
+// --- Stage 6: Verification Loop ---
+
+async function runVerificationLoop(rl, state) {
+  console.log('  Aider can auto-fix lint and test failures after edits.');
+  console.log('');
+
+  const lintCmd = await ask(rl, c('  Lint command (leave blank to skip): ', 'blue'));
+  state.lintCmd = lintCmd.trim() || null;
+
+  if (state.lintCmd) {
+    const autoLint = await ask(rl, c('  Enable auto-lint (auto-fix after edits)? (Y/n): ', 'blue'));
+    state.autoLint = autoLint.trim().toLowerCase() !== 'n';
+  }
+
+  const testCmd = await ask(rl, c('  Test command (leave blank to skip): ', 'blue'));
+  state.testCmd = testCmd.trim() || null;
+
+  if (state.testCmd) {
+    const autoTest = await ask(rl, c('  Enable auto-test (run tests after edits)? (Y/n): ', 'blue'));
+    state.autoTest = autoTest.trim().toLowerCase() !== 'n';
+  }
+
+  return 'next';
+}
+
+// --- Stage 7: CI Integration ---
+
+async function runCiIntegration(rl, state) {
+  console.log('  CI integration ensures Aider-generated code passes quality gates.');
+  console.log('');
+
+  const wantCi = await ask(rl, c('  Set up CI workflow for Aider PRs? (y/N): ', 'blue'));
+  state.wantCi = wantCi.trim().toLowerCase() === 'y';
+
+  return 'next';
+}
+
+// --- Stage 8: Review & Generate ---
+
+async function runReviewGenerate(rl, state, dir) {
+  console.log('  Summary:');
+  console.log(`    Auto-commits: ${state.autoCommits ? 'yes' : 'no'}`);
+  console.log(`    Attribution: ${state.attribution ? 'yes' : 'no'}`);
+  console.log(`    Commit prefix: "${state.commitPrefix}"`);
+  console.log(`    Main model: ${state.mainModel || 'default'}`);
+  console.log(`    Architect mode: ${state.architect ? 'yes' : 'no'}`);
+  console.log(`    Prompt caching: ${state.cachePrompts ? 'yes' : 'no'}`);
+  console.log(`    Generate conventions: ${state.generateConventions ? 'yes' : 'no'}`);
+  console.log(`    Domain packs: ${(state.domainPacks || []).join(', ') || 'none'}`);
+  console.log(`    Lint: ${state.lintCmd || 'none'} (auto: ${state.autoLint ? 'yes' : 'no'})`);
+  console.log(`    Test: ${state.testCmd || 'none'} (auto: ${state.autoTest ? 'yes' : 'no'})`);
+  console.log(`    CI workflow: ${state.wantCi ? 'yes' : 'no'}`);
+  console.log('');
+
+  const confirm = await ask(rl, c('  Generate files? (Y/n): ', 'blue'));
+  if (confirm.trim().toLowerCase() === 'n') {
+    return 'back';
+  }
+
+  setupAider({ dir, log: console.log });
+  return 'done';
+}
+
+// --- Main wizard ---
+
+async function aiderInteractive(dir) {
+  if (!isTTY()) {
+    console.log('Interactive mode requires a TTY. Use --setup instead.');
+    process.exit(1);
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log('');
+  console.log(c('  ╔══════════════════════════════════════╗', 'magenta'));
+  console.log(c('  ║       Aider Interactive Setup        ║', 'magenta'));
+  console.log(c('  ║         powered by nerviq            ║', 'magenta'));
+  console.log(c('  ╚══════════════════════════════════════╝', 'magenta'));
+
+  const ctx = new AiderProjectContext(dir);
+  const state = {
+    autoCommits: true,
+    attribution: true,
+    commitPrefix: 'aider: ',
+    mainModel: null,
+    architect: false,
+    cachePrompts: true,
+    generateConventions: true,
+    domainPacks: [],
+    lintCmd: null,
+    autoLint: false,
+    testCmd: null,
+    autoTest: false,
+    wantCi: false,
+  };
+
+  const stages = [
+    // Stage 1 — auto, no interaction
+    async () => {
+      printStageHeader(0);
+      const detection = runProjectDetection(ctx);
+      console.log(`  Project: ${detection.projectName}`);
+      console.log(`  Git repo: ${detection.hasGit ? c('yes', 'green') : c('NO — required!', 'red')}`);
+      console.log(`  .aider.conf.yml: ${detection.hasConfYml ? 'exists' : 'missing'}`);
+      console.log(`  Convention files: ${detection.hasConventions ? 'found' : 'none'}`);
+      console.log(`  Stacks: ${detection.stacks.map(s => s.key).join(', ') || 'none detected'}`);
+
+      if (!detection.hasGit) {
+        console.log('');
+        console.log(c('  Warning: Aider requires a git repo. Run `git init` first.', 'red'));
+      }
+
+      return 'next';
+    },
+    // Stage 2
+    async () => { printStageHeader(1); return runGitSafety(rl, state); },
+    // Stage 3
+    async () => { printStageHeader(2); return runModelConfig(rl, state); },
+    // Stage 4
+    async () => { printStageHeader(3); return runConventions(rl, state, ctx); },
+    // Stage 5
+    async () => { printStageHeader(4); return runDomainPacks(rl, state, ctx); },
+    // Stage 6
+    async () => { printStageHeader(5); return runVerificationLoop(rl, state); },
+    // Stage 7
+    async () => { printStageHeader(6); return runCiIntegration(rl, state); },
+    // Stage 8
+    async () => { printStageHeader(7); return runReviewGenerate(rl, state, dir); },
+  ];
+
+  let stageIndex = 0;
+
+  while (stageIndex < stages.length) {
+    const result = await stages[stageIndex]();
+
+    if (result === 'quit' || result === 'exit') {
+      rl.close();
+      console.log(c('  Setup cancelled.', 'yellow'));
+      return { cancelled: true };
+    }
+
+    if (result === 'back') {
+      if (stageIndex > 0) {
+        stageIndex--;
+      } else {
+        console.log(c('  Already at the first stage.', 'dim'));
+      }
+      continue;
+    }
+
+    if (result === 'done') {
+      break;
+    }
+
+    stageIndex++;
+  }
+
+  rl.close();
+
+  console.log('');
+  console.log(c('  Done! Run `npx nerviq --platform aider` to audit your setup.', 'green'));
+  console.log('');
+
+  return { cancelled: false, state };
+}
+
+module.exports = { aiderInteractive };

package/src/aider/mcp-packs.js

@@ -0,0 +1,98 @@
+/**
+ * Aider MCP Pack System — Minimal
+ *
+ * Aider has NO native MCP support. This module provides:
+ * - Recommendations for editor integrations that bridge MCP to Aider
+ * - Awareness of the --browser and /web commands for documentation
+ * - Future-proofing for when/if Aider adds MCP support
+ *
+ * Instead of MCP, Aider users should rely on:
+ * - /web command for pulling in web documentation
+ * - /read for adding files to context
+ * - Editor extensions (VS Code, NeoVim) that may have MCP bridges
+ */
+
+const AIDER_MCP_PACKS = [
+  {
+    key: 'editor-bridge-vscode',
+    label: 'VS Code Extension Bridge',
+    description: 'Use the Aider VS Code extension for tighter editor integration.',
+    useWhen: 'VS Code users who want in-editor Aider access.',
+    adoption: 'Recommended for VS Code users. Install from marketplace.',
+    trustLevel: 'high',
+    transport: 'editor-extension',
+    requiredAuth: [],
+    serverName: null,
+    configProjection: null,
+    recommendation: 'Install aider-chat VS Code extension for in-editor chat.',
+  },
+  {
+    key: 'editor-bridge-neovim',
+    label: 'NeoVim Plugin Bridge',
+    description: 'Use the Aider NeoVim plugin for terminal-native integration.',
+    useWhen: 'NeoVim users who want in-editor Aider access.',
+    adoption: 'Recommended for NeoVim users. Install via plugin manager.',
+    trustLevel: 'high',
+    transport: 'editor-plugin',
+    requiredAuth: [],
+    serverName: null,
+    configProjection: null,
+    recommendation: 'Install aider.nvim for NeoVim integration.',
+  },
+  {
+    key: 'web-docs',
+    label: 'Web Documentation (/web)',
+    description: 'Use Aider\'s built-in /web command to scrape documentation into context.',
+    useWhen: 'Any project where Aider needs live documentation context.',
+    adoption: 'Built-in feature, no setup required.',
+    trustLevel: 'high',
+    transport: 'built-in',
+    requiredAuth: [],
+    serverName: null,
+    configProjection: null,
+    recommendation: 'Use /web <url> to pull documentation into the Aider chat context.',
+  },
+];
+
+/**
+ * Recommend MCP-equivalent integrations for Aider.
+ * Since Aider has no native MCP, these are editor/workflow recommendations.
+ */
+function recommendAiderMcpPacks(ctx) {
+  const recommendations = [];
+
+  // Always recommend /web for docs
+  recommendations.push(AIDER_MCP_PACKS.find(p => p.key === 'web-docs'));
+
+  // Detect editor signals
+  const hasVscode = ctx.files.some(f => /\.vscode\//i.test(f));
+  const hasNvim = ctx.fileContent('.nvimrc') || ctx.fileContent('init.lua');
+
+  if (hasVscode) {
+    recommendations.push(AIDER_MCP_PACKS.find(p => p.key === 'editor-bridge-vscode'));
+  }
+
+  if (hasNvim) {
+    recommendations.push(AIDER_MCP_PACKS.find(p => p.key === 'editor-bridge-neovim'));
+  }
+
+  return recommendations.filter(Boolean);
+}
+
+/**
+ * Get preflight warnings for Aider MCP integration (minimal).
+ */
+function getAiderMcpPreflight() {
+  return {
+    warnings: [
+      'Aider has no native MCP support. Use /web command and editor extensions instead.',
+    ],
+    ready: true,
+  };
+}
+
+module.exports = {
+  AIDER_MCP_PACKS,
+  recommendAiderMcpPacks,
+  getAiderMcpPreflight,
+};

package/src/aider/patch.js

@@ -0,0 +1,214 @@
+/**
+ * Aider Patch Intelligence — managed blocks for YAML config
+ *
+ * Safe patching of existing Aider files using managed blocks.
+ * Supports .aider.conf.yml (YAML comment blocks) and CONVENTIONS.md (HTML comment blocks).
+ *
+ * Managed blocks are sections that nerviq controls.
+ * Hand-authored content outside managed blocks is preserved.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { writeRollbackArtifact, writeActivityArtifact } = require('../activity');
+
+// Managed block markers
+const MANAGED_START_MD = '<!-- nerviq:managed:start -->';
+const MANAGED_END_MD = '<!-- nerviq:managed:end -->';
+const MANAGED_START_YAML = '# <!-- nerviq:managed:start -->';
+const MANAGED_END_YAML = '# <!-- nerviq:managed:end -->';
+
+/**
+ * Extract managed blocks from a file.
+ */
+function extractManagedBlock(content, startMarker, endMarker) {
+  const startIdx = content.indexOf(startMarker);
+  const endIdx = content.indexOf(endMarker);
+
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
+    return { before: content, managed: null, after: '' };
+  }
+
+  return {
+    before: content.substring(0, startIdx),
+    managed: content.substring(startIdx + startMarker.length, endIdx).trim(),
+    after: content.substring(endIdx + endMarker.length),
+  };
+}
+
+/**
+ * Replace or insert a managed block in a file.
+ */
+function upsertManagedBlock(content, newManaged, startMarker, endMarker) {
+  const { before, managed, after } = extractManagedBlock(content, startMarker, endMarker);
+
+  if (managed !== null) {
+    return `${before}${startMarker}\n${newManaged}\n${endMarker}${after}`;
+  }
+
+  const separator = content.endsWith('\n') ? '\n' : '\n\n';
+  return `${content}${separator}${startMarker}\n${newManaged}\n${endMarker}\n`;
+}
+
+/**
+ * Patch CONVENTIONS.md with managed sections.
+ */
+function patchConventionsMd(existingContent, managedSections) {
+  const newManaged = Object.entries(managedSections)
+    .map(([section, content]) => `## ${section}\n${content}`)
+    .join('\n\n');
+
+  return upsertManagedBlock(existingContent, newManaged, MANAGED_START_MD, MANAGED_END_MD);
+}
+
+/**
+ * Patch .aider.conf.yml by safely adding new keys.
+ * Never weakens existing safety settings (auto-commits, etc.).
+ * Only adds keys that don't already exist.
+ */
+function patchAiderConfYml(existingContent, newKeys) {
+  const existingKeys = new Set();
+  const lines = existingContent.split(/\r?\n/);
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const colonIdx = trimmed.indexOf(':');
+    if (colonIdx > 0) {
+      existingKeys.add(trimmed.slice(0, colonIdx).trim());
+    }
+  }
+
+  const additions = [];
+  for (const [key, value] of Object.entries(newKeys)) {
+    if (existingKeys.has(key)) continue;
+
+    // Safety: never weaken these settings
+    if (key === 'auto-commits' && value === false) continue;
+    if (key === 'yes-always' && value === true) continue;
+
+    if (typeof value === 'string') {
+      additions.push(`${key}: "${value}"`);
+    } else if (typeof value === 'boolean' || typeof value === 'number') {
+      additions.push(`${key}: ${value}`);
+    } else if (Array.isArray(value)) {
+      additions.push(`${key}:`);
+      for (const item of value) {
+        additions.push(`  - ${item}`);
+      }
+    }
+  }
+
+  if (additions.length === 0) return existingContent;
+
+  const newContent = additions.join('\n');
+  return upsertManagedBlock(existingContent, newContent, MANAGED_START_YAML, MANAGED_END_YAML);
+}
+
+/**
+ * Detect mixed-platform repo (e.g., has both .aider.conf.yml and CLAUDE.md).
+ */
+function detectMixedAiderRepo(ctx) {
+  const platforms = [];
+
+  if (ctx.fileContent('.aider.conf.yml')) platforms.push('aider');
+  if (ctx.fileContent('CLAUDE.md') || ctx.fileContent('.claude/CLAUDE.md')) platforms.push('claude');
+  if (ctx.fileContent('AGENTS.md') || ctx.fileContent('.codex')) platforms.push('codex');
+  if (ctx.fileContent('.cursor/rules') || ctx.fileContent('.cursorrules')) platforms.push('cursor');
+  if (ctx.fileContent('.github/copilot-instructions.md')) platforms.push('copilot');
+
+  return {
+    isMultiPlatform: platforms.length > 1,
+    platforms,
+    primaryPlatform: platforms[0] || null,
+  };
+}
+
+/**
+ * Generate a patch preview without writing.
+ */
+function generatePatchPreview(ctx, patches = {}) {
+  const previews = [];
+
+  if (patches.confYml) {
+    const existing = ctx.configContent ? (ctx.configContent() || '') : '';
+    const patched = existing
+      ? patchAiderConfYml(existing, patches.confYml)
+      : Object.entries(patches.confYml).map(([k, v]) => `${k}: ${v}`).join('\n');
+
+    previews.push({
+      file: '.aider.conf.yml',
+      exists: Boolean(existing),
+      unchanged: patched === existing,
+      preview: patched,
+    });
+  }
+
+  if (patches.conventions) {
+    const existing = ctx.fileContent('CONVENTIONS.md') || '';
+    const patched = existing
+      ? patchConventionsMd(existing, patches.conventions)
+      : Object.entries(patches.conventions).map(([s, c]) => `## ${s}\n${c}`).join('\n\n');
+
+    previews.push({
+      file: 'CONVENTIONS.md',
+      exists: Boolean(existing),
+      unchanged: patched === existing,
+      preview: patched,
+    });
+  }
+
+  return previews;
+}
+
+/**
+ * Apply patches to disk with rollback support.
+ */
+function applyPatch(dir, filePath, newContent) {
+  const fullPath = path.join(dir, filePath);
+  const existed = fs.existsSync(fullPath);
+  const originalContent = existed ? fs.readFileSync(fullPath, 'utf8') : null;
+
+  if (existed && originalContent === newContent) {
+    return { success: true, reason: 'unchanged', unchanged: true };
+  }
+
+  const dirName = path.dirname(fullPath);
+  if (!fs.existsSync(dirName)) {
+    fs.mkdirSync(dirName, { recursive: true });
+  }
+
+  fs.writeFileSync(fullPath, newContent, 'utf8');
+
+  const rollback = writeRollbackArtifact(dir, 'aider-patch', [filePath], {
+    [filePath]: originalContent,
+  });
+
+  const activity = writeActivityArtifact(dir, 'aider-patch', {
+    platform: 'aider',
+    patchedFiles: [filePath],
+    rollbackArtifact: rollback.relativePath,
+  });
+
+  return {
+    success: true,
+    reason: 'patched',
+    unchanged: false,
+    rollbackArtifact: rollback.relativePath,
+    activityArtifact: activity.relativePath,
+  };
+}
+
+module.exports = {
+  MANAGED_START_MD,
+  MANAGED_END_MD,
+  MANAGED_START_YAML,
+  MANAGED_END_YAML,
+  extractManagedBlock,
+  upsertManagedBlock,
+  patchConventionsMd,
+  patchAiderConfYml,
+  detectMixedAiderRepo,
+  generatePatchPreview,
+  applyPatch,
+};