@nerviq/cli 0.0.1 → 0.9.0-beta.2

package/src/aider/activity.js

@@ -0,0 +1,226 @@
+/**
+ * Aider Repeat-Usage Surfaces — 6 activity surfaces
+ *
+ * Adapts the shared activity/snapshot backend for Aider platform.
+ * Provides: history, compare, trend, watch, feedback, insights.
+ *
+ * Aider snapshots stored in .claude/claudex-setup/snapshots/ filtered by platform='aider'.
+ */
+
+const path = require('path');
+const {
+  getHistory: getSharedHistory,
+  compareLatest: sharedCompareLatest,
+  readSnapshotIndex,
+  writeSnapshotArtifact,
+  exportTrendReport: sharedExportTrendReport,
+  recordRecommendationOutcome,
+  readOutcomeIndex,
+  summarizeOutcomeEntries,
+} = require('../activity');
+const { version } = require('../../package.json');
+
+// --- History ---
+
+function getAiderHistory(dir, limit = 20) {
+  const entries = readSnapshotIndex(dir);
+  return entries
+    .filter(e => e.snapshotKind === 'audit' && (e.platform === 'aider' || e.summary?.platform === 'aider'))
+    .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
+    .slice(0, limit);
+}
+
+function formatAiderHistory(dir) {
+  const history = getAiderHistory(dir, 10);
+  if (history.length === 0) {
+    return 'No Aider snapshots found. Run `npx nerviq --platform aider --snapshot` to save one.';
+  }
+
+  const lines = ['Aider Score History (most recent first):', ''];
+  for (const entry of history) {
+    const date = entry.createdAt?.split('T')[0] || 'unknown';
+    const score = entry.summary?.score ?? '?';
+    const passed = entry.summary?.passed ?? '?';
+    const total = entry.summary?.checkCount ?? '?';
+    lines.push(`  ${date}  ${score}/100  (${passed}/${total} passing)`);
+  }
+
+  const comparison = compareAiderLatest(dir);
+  if (comparison) {
+    lines.push('');
+    const sign = comparison.delta.score >= 0 ? '+' : '';
+    lines.push(`  Trend: ${comparison.trend} (${sign}${comparison.delta.score} since previous)`);
+    if (comparison.improvements.length > 0) {
+      lines.push(`  Fixed: ${comparison.improvements.join(', ')}`);
+    }
+    if (comparison.regressions.length > 0) {
+      lines.push(`  New gaps: ${comparison.regressions.join(', ')}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+// --- Compare ---
+
+function compareAiderLatest(dir) {
+  const audits = getAiderHistory(dir, 2);
+  if (audits.length < 2) return null;
+
+  const current = audits[0];
+  const previous = audits[1];
+
+  const currentPassed = new Set(current.summary?.passedIds || []);
+  const previousPassed = new Set(previous.summary?.passedIds || []);
+
+  const improvements = [];
+  const regressions = [];
+
+  for (const id of currentPassed) {
+    if (!previousPassed.has(id)) improvements.push(id);
+  }
+  for (const id of previousPassed) {
+    if (!currentPassed.has(id)) regressions.push(id);
+  }
+
+  const scoreDelta = (current.summary?.score ?? 0) - (previous.summary?.score ?? 0);
+
+  return {
+    trend: scoreDelta > 0 ? 'improving' : scoreDelta < 0 ? 'regressing' : 'stable',
+    delta: { score: scoreDelta },
+    improvements,
+    regressions,
+    currentSnapshot: current,
+    previousSnapshot: previous,
+  };
+}
+
+// --- Trend Export ---
+
+function exportAiderTrendReport(dir) {
+  const history = getAiderHistory(dir, 50);
+  if (history.length === 0) return null;
+
+  return {
+    platform: 'aider',
+    generatedAt: new Date().toISOString(),
+    nerviqVersion: version,
+    snapshotCount: history.length,
+    dataPoints: history.map(entry => ({
+      date: entry.createdAt,
+      score: entry.summary?.score ?? null,
+      passed: entry.summary?.passed ?? null,
+      checkCount: entry.summary?.checkCount ?? null,
+    })),
+  };
+}
+
+// --- Feedback ---
+
+function recordAiderFeedback(dir, recommendationId, outcome, notes = '') {
+  return recordRecommendationOutcome(dir, {
+    platform: 'aider',
+    recommendationId,
+    outcome,
+    notes,
+  });
+}
+
+function getAiderFeedbackSummary(dir) {
+  const entries = readOutcomeIndex(dir);
+  const aiderEntries = entries.filter(e => e.platform === 'aider');
+  return summarizeOutcomeEntries(aiderEntries);
+}
+
+function formatAiderFeedback(dir) {
+  const summary = getAiderFeedbackSummary(dir);
+  if (summary.total === 0) {
+    return 'No Aider recommendation feedback recorded yet.';
+  }
+
+  const lines = [
+    'Aider Recommendation Feedback:',
+    '',
+    `  Total: ${summary.total}`,
+    `  Accepted: ${summary.accepted}`,
+    `  Rejected: ${summary.rejected}`,
+    `  Deferred: ${summary.deferred}`,
+  ];
+
+  if (summary.acceptanceRate !== null) {
+    lines.push(`  Acceptance rate: ${(summary.acceptanceRate * 100).toFixed(0)}%`);
+  }
+
+  return lines.join('\n');
+}
+
+// --- Insights ---
+
+function generateAiderInsights(dir) {
+  const history = getAiderHistory(dir, 10);
+  const feedback = getAiderFeedbackSummary(dir);
+  const insights = [];
+
+  if (history.length >= 3) {
+    const recent = history.slice(0, 3);
+    const avgScore = recent.reduce((sum, e) => sum + (e.summary?.score ?? 0), 0) / recent.length;
+
+    if (avgScore < 40) {
+      insights.push({
+        severity: 'high',
+        message: 'Aider setup score consistently low — prioritize .aider.conf.yml and CONVENTIONS.md.',
+      });
+    }
+
+    const comparison = compareAiderLatest(dir);
+    if (comparison && comparison.regressions.length > 2) {
+      insights.push({
+        severity: 'medium',
+        message: `${comparison.regressions.length} checks regressed since last snapshot.`,
+      });
+    }
+  }
+
+  if (feedback.total > 5 && feedback.acceptanceRate !== null && feedback.acceptanceRate < 0.5) {
+    insights.push({
+      severity: 'medium',
+      message: 'Low recommendation acceptance rate — review convention file relevance.',
+    });
+  }
+
+  return {
+    platform: 'aider',
+    insights,
+    summary: insights.length === 0
+      ? 'No actionable Aider insights at this time.'
+      : `${insights.length} Aider insight(s) found.`,
+  };
+}
+
+function formatAiderInsights(dir) {
+  const result = generateAiderInsights(dir);
+  if (result.insights.length === 0) {
+    return result.summary;
+  }
+
+  const lines = ['Aider Insights:', ''];
+  for (const insight of result.insights) {
+    const severity = insight.severity.toUpperCase();
+    lines.push(`  [${severity}] ${insight.message}`);
+  }
+  lines.push('');
+  lines.push(result.summary);
+  return lines.join('\n');
+}
+
+module.exports = {
+  getAiderHistory,
+  formatAiderHistory,
+  compareAiderLatest,
+  exportAiderTrendReport,
+  recordAiderFeedback,
+  getAiderFeedbackSummary,
+  formatAiderFeedback,
+  generateAiderInsights,
+  formatAiderInsights,
+};

package/src/aider/config-parser.js

@@ -0,0 +1,166 @@
+/**
+ * Aider Config Parser — YAML parser for .aider.conf.yml
+ *
+ * Aider uses YAML config (.aider.conf.yml) with a 4-level precedence:
+ *   env vars > CLI args > .aider.conf.yml > defaults
+ *
+ * This is a lightweight YAML subset parser (no dependency on js-yaml).
+ * Handles the flat key-value pairs and simple lists that .aider.conf.yml uses.
+ */
+
+function stripInlineComment(line) {
+  let inSingle = false;
+  let inDouble = false;
+
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    const prev = i > 0 ? line[i - 1] : '';
+
+    if (char === "'" && !inDouble && prev !== '\\') {
+      inSingle = !inSingle;
+      continue;
+    }
+
+    if (char === '"' && !inSingle && prev !== '\\') {
+      inDouble = !inDouble;
+      continue;
+    }
+
+    if (char === '#' && !inSingle && !inDouble) {
+      return line.slice(0, i).trimEnd();
+    }
+  }
+
+  return line;
+}
+
+function parseYamlValue(rawValue) {
+  const value = rawValue.trim();
+
+  if (value === '' || value === '~' || value === 'null') return null;
+  if (value === 'true' || value === 'True' || value === 'TRUE') return true;
+  if (value === 'false' || value === 'False' || value === 'FALSE') return false;
+
+  if (/^-?\d+$/.test(value)) return Number.parseInt(value, 10);
+  if (/^-?\d+\.\d+$/.test(value)) return Number.parseFloat(value);
+
+  // Quoted strings
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    return value.slice(1, -1);
+  }
+
+  // Inline list: [a, b, c]
+  if (value.startsWith('[') && value.endsWith(']')) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner) return [];
+    return inner.split(',').map(item => parseYamlValue(item.trim()));
+  }
+
+  return value;
+}
+
+function getIndentLevel(line) {
+  const match = line.match(/^(\s*)/);
+  return match ? match[1].length : 0;
+}
+
+/**
+ * Parse a simple YAML config file (flat keys, simple lists, no nested objects).
+ * Covers the subset used by .aider.conf.yml and .aider.model.settings.yml.
+ */
+function parseYaml(content) {
+  const root = {};
+  const lines = content.split(/\r?\n/);
+  let currentKey = null;
+  let collectingList = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+    const stripped = stripInlineComment(rawLine);
+    const trimmed = stripped.trim();
+
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    const indent = getIndentLevel(stripped);
+
+    // List item under a key
+    if (trimmed.startsWith('- ') && collectingList && currentKey) {
+      const listValue = parseYamlValue(trimmed.slice(2).trim());
+      if (!Array.isArray(root[currentKey])) {
+        root[currentKey] = [];
+      }
+      root[currentKey].push(listValue);
+      continue;
+    }
+
+    // Key-value pair
+    const colonIdx = trimmed.indexOf(':');
+    if (colonIdx === -1) {
+      throw new Error(`Line ${i + 1}: expected key: value — got "${trimmed}"`);
+    }
+
+    const key = trimmed.slice(0, colonIdx).trim();
+    const afterColon = trimmed.slice(colonIdx + 1).trim();
+
+    if (!afterColon) {
+      // Could be start of a list or nested block
+      currentKey = key;
+      collectingList = true;
+      continue;
+    }
+
+    collectingList = false;
+    currentKey = key;
+    root[key] = parseYamlValue(afterColon);
+  }
+
+  return root;
+}
+
+function tryParseYaml(content) {
+  try {
+    return { ok: true, data: parseYaml(content), error: null };
+  } catch (error) {
+    return { ok: false, data: null, error: error.message };
+  }
+}
+
+function getValueByKey(obj, key) {
+  if (!obj || typeof obj !== 'object') return undefined;
+  return obj[key];
+}
+
+/**
+ * Parse .env file content into key-value pairs.
+ */
+function parseDotEnv(content) {
+  const result = {};
+  const lines = content.split(/\r?\n/);
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    const eqIdx = trimmed.indexOf('=');
+    if (eqIdx === -1) continue;
+
+    const key = trimmed.slice(0, eqIdx).trim();
+    let value = trimmed.slice(eqIdx + 1).trim();
+
+    // Strip surrounding quotes
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+
+    result[key] = value;
+  }
+
+  return result;
+}
+
+module.exports = {
+  parseYaml,
+  tryParseYaml,
+  getValueByKey,
+  parseDotEnv,
+};

package/src/aider/context.js

@@ -0,0 +1,158 @@
+/**
+ * Aider Project Context
+ *
+ * Aider is a git-first CLI tool. Key surfaces:
+ * - .aider.conf.yml (project-level YAML config)
+ * - .aider.model.settings.yml (model role configuration)
+ * - .env (API keys, model overrides)
+ * - Convention files (passed explicitly via --read or --convention)
+ * - .gitignore (must include .aider* artifacts)
+ * - Git repo (Aider's ONLY safety mechanism — commits before changes)
+ *
+ * 4-level config precedence: env vars > CLI args > .aider.conf.yml > defaults
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { ProjectContext } = require('../context');
+const { tryParseYaml, getValueByKey, parseDotEnv } = require('./config-parser');
+
+let aiderVersionCache = null;
+
+function detectAiderVersion() {
+  if (aiderVersionCache !== null) {
+    return aiderVersionCache;
+  }
+
+  try {
+    const result = spawnSync('aider', ['--version'], { encoding: 'utf8' });
+    const output = `${result.stdout || ''} ${result.stderr || ''}`.trim();
+    const match = output.match(/aider\s+v?([^\s]+)/i);
+    aiderVersionCache = match ? match[1] : (output || null);
+    return aiderVersionCache;
+  } catch {
+    aiderVersionCache = null;
+    return null;
+  }
+}
+
+class AiderProjectContext extends ProjectContext {
+  configContent() {
+    return this.fileContent('.aider.conf.yml');
+  }
+
+  modelSettingsContent() {
+    return this.fileContent('.aider.model.settings.yml');
+  }
+
+  envContent() {
+    return this.fileContent('.env');
+  }
+
+  parsedConfig() {
+    const content = this.configContent();
+    if (!content) {
+      return { ok: false, data: null, error: 'missing .aider.conf.yml', source: '.aider.conf.yml' };
+    }
+    const parsed = tryParseYaml(content);
+    return { ...parsed, source: '.aider.conf.yml' };
+  }
+
+  parsedModelSettings() {
+    const content = this.modelSettingsContent();
+    if (!content) {
+      return { ok: false, data: null, error: 'missing .aider.model.settings.yml', source: '.aider.model.settings.yml' };
+    }
+    const parsed = tryParseYaml(content);
+    return { ...parsed, source: '.aider.model.settings.yml' };
+  }
+
+  parsedEnv() {
+    const content = this.envContent();
+    if (!content) return {};
+    return parseDotEnv(content);
+  }
+
+  configValue(key) {
+    const parsed = this.parsedConfig();
+    if (parsed.ok) {
+      const value = getValueByKey(parsed.data, key);
+      if (value !== undefined) return value;
+    }
+    return undefined;
+  }
+
+  conventionFiles() {
+    // Aider convention files are explicitly listed in config or CLI
+    const readFiles = this.configValue('read') || [];
+    const conventionFiles = Array.isArray(readFiles) ? readFiles : [readFiles];
+
+    // Also check for common convention file names
+    const commonNames = ['CONVENTIONS.md', 'CODING_CONVENTIONS.md', '.aider.conventions.md', 'STYLE.md'];
+    for (const name of commonNames) {
+      if (this.fileContent(name) && !conventionFiles.includes(name)) {
+        conventionFiles.push(name);
+      }
+    }
+
+    return conventionFiles.filter(Boolean);
+  }
+
+  gitignoreContent() {
+    return this.fileContent('.gitignore');
+  }
+
+  hasGitRepo() {
+    try {
+      return fs.existsSync(path.join(this.dir, '.git'));
+    } catch {
+      return false;
+    }
+  }
+
+  gitStatus() {
+    try {
+      const result = spawnSync('git', ['status', '--porcelain'], {
+        cwd: this.dir,
+        encoding: 'utf8',
+      });
+      return (result.stdout || '').trim();
+    } catch {
+      return null;
+    }
+  }
+
+  workflowFiles() {
+    return this.dirFiles('.github/workflows')
+      .filter(file => /\.ya?ml$/i.test(file))
+      .map(file => path.join('.github', 'workflows', file).replace(/\\/g, '/'));
+  }
+
+  /** Aider model roles: main (coding), editor (applying), weak (commit messages) */
+  modelRoles() {
+    const config = this.parsedConfig();
+    const data = config.ok ? config.data : {};
+    return {
+      main: data.model || data['main-model'] || null,
+      editor: data['editor-model'] || null,
+      weak: data['weak-model'] || null,
+      architect: data.architect || false,
+    };
+  }
+
+  static isAiderRepo(dir) {
+    try {
+      return fs.existsSync(path.join(dir, '.aider.conf.yml')) ||
+        fs.existsSync(path.join(dir, '.aider.model.settings.yml')) ||
+        fs.existsSync(path.join(dir, '.aider.tags.cache.v3'));
+    } catch {
+      return false;
+    }
+  }
+}
+
+module.exports = {
+  AiderProjectContext,
+  detectAiderVersion,
+};