@nerviq/cli 0.0.1 → 0.9.0-beta.1

package/src/opencode/activity.js

@@ -0,0 +1,286 @@
+/**
+ * OpenCode Repeat-Usage Surfaces — 6 repeat-usage surfaces
+ *
+ * Adapts the shared activity/snapshot backend for OpenCode platform.
+ * Provides: history, compare, trend, watch, feedback, insights.
+ *
+ * OpenCode snapshots are stored alongside Claude snapshots in
+ * .claude/claudex-setup/snapshots/ but filtered by platform='opencode'.
+ */
+
+const path = require('path');
+const {
+  readSnapshotIndex,
+  writeSnapshotArtifact,
+  exportTrendReport: sharedExportTrendReport,
+  recordRecommendationOutcome,
+  readOutcomeIndex,
+  summarizeOutcomeEntries,
+} = require('../activity');
+const { version } = require('../../package.json');
+
+// --- History ---
+
+function getOpenCodeHistory(dir, limit = 20) {
+  const entries = readSnapshotIndex(dir);
+  return entries
+    .filter(e => e.snapshotKind === 'audit' && (e.platform === 'opencode' || e.summary?.platform === 'opencode'))
+    .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
+    .slice(0, limit);
+}
+
+function formatOpenCodeHistory(dir) {
+  const history = getOpenCodeHistory(dir, 10);
+  if (history.length === 0) {
+    return 'No OpenCode snapshots found. Run `npx nerviq --platform opencode --snapshot` to save one.';
+  }
+
+  const lines = ['OpenCode 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 = compareOpenCodeLatest(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 compareOpenCodeLatest(dir) {
+  const audits = getOpenCodeHistory(dir, 2);
+  if (audits.length < 2) return null;
+
+  const current = audits[0];
+  const previous = audits[1];
+
+  const delta = {
+    score: (current.summary?.score || 0) - (previous.summary?.score || 0),
+    organic: (current.summary?.organicScore || 0) - (previous.summary?.organicScore || 0),
+    passed: (current.summary?.passed || 0) - (previous.summary?.passed || 0),
+  };
+
+  const regressions = [];
+  const improvements = [];
+  const prevKeys = new Set(previous.summary?.topActionKeys || []);
+  const currKeys = new Set(current.summary?.topActionKeys || []);
+  for (const key of currKeys) { if (!prevKeys.has(key)) regressions.push(key); }
+  for (const key of prevKeys) { if (!currKeys.has(key)) improvements.push(key); }
+
+  return {
+    platform: 'opencode',
+    current: { date: current.createdAt, score: current.summary?.score, passed: current.summary?.passed },
+    previous: { date: previous.createdAt, score: previous.summary?.score, passed: previous.summary?.passed },
+    delta,
+    regressions,
+    improvements,
+    trend: delta.score > 0 ? 'improving' : delta.score < 0 ? 'regressing' : 'stable',
+  };
+}
+
+// --- Trend ---
+
+function exportOpenCodeTrendReport(dir) {
+  const history = getOpenCodeHistory(dir, 50);
+  if (history.length === 0) return null;
+
+  const comparison = compareOpenCodeLatest(dir);
+  const lines = [
+    '# OpenCode Setup Trend Report',
+    '',
+    `**Project:** ${path.basename(dir)}`,
+    '**Platform:** OpenCode',
+    `**Generated:** ${new Date().toISOString().split('T')[0]}`,
+    `**Snapshots:** ${history.length}`,
+    '',
+    '## Score History',
+    '',
+    '| Date | Score | Passed | Checks |',
+    '|------|-------|--------|--------|',
+  ];
+
+  for (const entry of history) {
+    const date = entry.createdAt?.split('T')[0] || '?';
+    lines.push(`| ${date} | ${entry.summary?.score ?? '?'}/100 | ${entry.summary?.passed ?? '?'} | ${entry.summary?.checkCount ?? '?'} |`);
+  }
+
+  if (comparison) {
+    lines.push('');
+    lines.push('## Latest Comparison');
+    lines.push('');
+    lines.push(`- **Previous:** ${comparison.previous.score}/100 (${comparison.previous.date?.split('T')[0]})`);
+    lines.push(`- **Current:** ${comparison.current.score}/100 (${comparison.current.date?.split('T')[0]})`);
+    lines.push(`- **Delta:** ${comparison.delta.score >= 0 ? '+' : ''}${comparison.delta.score} points`);
+    lines.push(`- **Trend:** ${comparison.trend}`);
+    if (comparison.improvements.length > 0) lines.push(`- **Fixed:** ${comparison.improvements.join(', ')}`);
+    if (comparison.regressions.length > 0) lines.push(`- **New gaps:** ${comparison.regressions.join(', ')}`);
+  }
+
+  if (history.length >= 3) {
+    lines.push('');
+    lines.push('## Trend Chart');
+    lines.push('');
+    lines.push('```');
+    const scores = history.slice().reverse().map(e => e.summary?.score ?? 0);
+    const max = Math.max(...scores, 100);
+    const chartHeight = 10;
+    for (let row = chartHeight; row >= 0; row--) {
+      const threshold = (row / chartHeight) * max;
+      const rowLabel = String(Math.round(threshold)).padStart(3);
+      const bar = scores.map(s => s >= threshold ? '#' : ' ').join('');
+      lines.push(`${rowLabel} |${bar}`);
+    }
+    lines.push(`    +${'─'.repeat(scores.length)}`);
+    lines.push('```');
+  }
+
+  lines.push('');
+  lines.push('---');
+  lines.push(`*Generated by nerviq v${version} for OpenCode*`);
+  return lines.join('\n');
+}
+
+// --- Feedback ---
+
+function recordOpenCodeFeedback(dir, payload) {
+  return recordRecommendationOutcome(dir, {
+    ...payload,
+    source: payload.source || 'opencode-cli',
+    platform: 'opencode',
+  });
+}
+
+function getOpenCodeFeedbackSummary(dir) {
+  const entries = readOutcomeIndex(dir)
+    .filter(e => e.source === 'opencode-cli' || e.platform === 'opencode');
+  return summarizeOutcomeEntries(entries);
+}
+
+function formatOpenCodeFeedback(dir) {
+  const summary = getOpenCodeFeedbackSummary(dir);
+  if (!summary || Object.keys(summary).length === 0) {
+    return 'No OpenCode feedback recorded yet.';
+  }
+
+  const lines = ['OpenCode Recommendation Feedback:', ''];
+  const entries = Array.isArray(summary) ? summary : Object.values(summary);
+  for (const entry of entries) {
+    const key = entry.key || 'unknown';
+    const accepted = entry.accepted || 0;
+    const rejected = entry.rejected || 0;
+    const total = entry.total || 0;
+    lines.push(`  ${key}: ${accepted} accepted, ${rejected} rejected (${total} total)`);
+  }
+  return lines.join('\n');
+}
+
+// --- Insights ---
+
+function generateOpenCodeInsights(dir) {
+  const history = getOpenCodeHistory(dir, 50);
+  const feedback = getOpenCodeFeedbackSummary(dir);
+  const insights = [];
+
+  if (history.length >= 3) {
+    const recentFailKeys = new Map();
+    for (const entry of history.slice(0, 5)) {
+      for (const key of (entry.summary?.topActionKeys || [])) {
+        recentFailKeys.set(key, (recentFailKeys.get(key) || 0) + 1);
+      }
+    }
+    for (const [key, count] of recentFailKeys) {
+      if (count >= 3) {
+        insights.push({
+          type: 'persistent-failure',
+          severity: 'high',
+          key,
+          message: `Check ${key} has failed in ${count} of the last ${Math.min(history.length, 5)} audits.`,
+        });
+      }
+    }
+  }
+
+  if (history.length >= 2) {
+    const scores = history.map(e => e.summary?.score ?? 0);
+    if (scores[0] < scores[1]) {
+      insights.push({
+        type: 'regression-pattern',
+        severity: 'medium',
+        message: `Score dropped from ${scores[1]} to ${scores[0]} in the most recent audit.`,
+        delta: scores[0] - scores[1],
+      });
+    }
+  }
+
+  if (history.length >= 5) {
+    const recentScores = history.slice(0, 5).map(e => e.summary?.score ?? 0);
+    const range = Math.max(...recentScores) - Math.min(...recentScores);
+    if (range <= 2) {
+      insights.push({
+        type: 'velocity-stall',
+        severity: 'low',
+        message: `Score has been flat (range: ${range} points) over the last 5 audits.`,
+      });
+    }
+  }
+
+  const feedbackEntries = Array.isArray(feedback) ? feedback : Object.values(feedback || {});
+  for (const entry of feedbackEntries) {
+    if (entry.rejected > entry.accepted && entry.total >= 2) {
+      insights.push({
+        type: 'feedback-signal',
+        severity: 'medium',
+        key: entry.key,
+        message: `Recommendation ${entry.key} has been rejected more than accepted (${entry.rejected}/${entry.total}).`,
+      });
+    }
+  }
+
+  return {
+    platform: 'opencode',
+    generatedAt: new Date().toISOString(),
+    snapshotCount: history.length,
+    feedbackCount: feedbackEntries.length,
+    insights,
+    summary: insights.length === 0
+      ? 'No actionable insights detected. Keep running audits to build pattern data.'
+      : `${insights.length} insight(s) detected across ${history.length} snapshots.`,
+  };
+}
+
+function formatOpenCodeInsights(dir) {
+  const result = generateOpenCodeInsights(dir);
+  if (result.insights.length === 0) return result.summary;
+
+  const lines = ['OpenCode 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 = {
+  getOpenCodeHistory,
+  formatOpenCodeHistory,
+  compareOpenCodeLatest,
+  exportOpenCodeTrendReport,
+  recordOpenCodeFeedback,
+  getOpenCodeFeedbackSummary,
+  formatOpenCodeFeedback,
+  generateOpenCodeInsights,
+  formatOpenCodeInsights,
+};

package/src/opencode/config-parser.js

@@ -0,0 +1,109 @@
+/**
+ * OpenCode JSONC Parser
+ *
+ * Parses JSONC (JSON with Comments) format used by opencode.json / opencode.jsonc.
+ * Strips single-line (//) and multi-line comments before parsing.
+ */
+
+function stripJsoncComments(content) {
+  let result = '';
+  let inString = false;
+  let inSingleLineComment = false;
+  let inMultiLineComment = false;
+
+  for (let i = 0; i < content.length; i++) {
+    const char = content[i];
+    const next = i + 1 < content.length ? content[i + 1] : '';
+    const prev = i > 0 ? content[i - 1] : '';
+
+    if (inSingleLineComment) {
+      if (char === '\n') {
+        inSingleLineComment = false;
+        result += char;
+      }
+      continue;
+    }
+
+    if (inMultiLineComment) {
+      if (char === '*' && next === '/') {
+        inMultiLineComment = false;
+        i++; // skip closing /
+      } else if (char === '\n') {
+        result += char; // preserve newlines for line counting
+      }
+      continue;
+    }
+
+    if (inString) {
+      result += char;
+      if (char === '"' && prev !== '\\') {
+        inString = false;
+      }
+      continue;
+    }
+
+    // Not in string or comment
+    if (char === '"') {
+      inString = true;
+      result += char;
+      continue;
+    }
+
+    if (char === '/' && next === '/') {
+      inSingleLineComment = true;
+      i++; // skip second /
+      continue;
+    }
+
+    if (char === '/' && next === '*') {
+      inMultiLineComment = true;
+      i++; // skip *
+      continue;
+    }
+
+    result += char;
+  }
+
+  return result;
+}
+
+/**
+ * Strip trailing commas from JSON (common in JSONC).
+ */
+function stripTrailingCommas(content) {
+  return content.replace(/,\s*([\]}])/g, '$1');
+}
+
+function parseJsonc(content) {
+  const stripped = stripTrailingCommas(stripJsoncComments(content));
+  return JSON.parse(stripped);
+}
+
+function tryParseJsonc(content) {
+  try {
+    return { ok: true, data: parseJsonc(content), error: null };
+  } catch (error) {
+    return { ok: false, data: null, error: error.message };
+  }
+}
+
+function getValueByPath(obj, dottedPath) {
+  if (!obj) return undefined;
+  const parts = dottedPath.split('.').filter(Boolean);
+  let cursor = obj;
+  for (const part of parts) {
+    if (cursor == null || typeof cursor !== 'object' || !(part in cursor)) {
+      return undefined;
+    }
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+
+module.exports = {
+  stripJsoncComments,
+  stripTrailingCommas,
+  parseJsonc,
+  tryParseJsonc,
+  getValueByPath,
+};

package/src/opencode/context.js

@@ -0,0 +1,247 @@
+/**
+ * OpenCode Project Context
+ *
+ * Reads and caches OpenCode-specific project surfaces:
+ * - opencode.json / opencode.jsonc (JSONC config)
+ * - AGENTS.md (shared with Codex/Copilot)
+ * - Permission configuration
+ * - Plugin system
+ * - 6-level config merge hierarchy
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { ProjectContext } = require('../context');
+const { tryParseJsonc, getValueByPath } = require('./config-parser');
+
+let opencodeVersionCache = null;
+
+function detectOpencodeVersion() {
+  if (opencodeVersionCache !== null) {
+    return opencodeVersionCache;
+  }
+
+  try {
+    const result = spawnSync('opencode', ['--version'], { encoding: 'utf8' });
+    const output = `${result.stdout || ''} ${result.stderr || ''}`.trim();
+    const match = output.match(/opencode\s+v?([^\s]+)/i);
+    opencodeVersionCache = match ? match[1] : (output || null);
+    return opencodeVersionCache;
+  } catch {
+    opencodeVersionCache = null;
+    return null;
+  }
+}
+
+function listDirs(fullPath) {
+  try {
+    return fs.readdirSync(fullPath, { withFileTypes: true }).filter(entry => entry.isDirectory());
+  } catch {
+    return [];
+  }
+}
+
+class OpenCodeProjectContext extends ProjectContext {
+  configContent() {
+    return this.fileContent('opencode.json') || this.fileContent('opencode.jsonc');
+  }
+
+  configFileName() {
+    if (this.fileContent('opencode.json')) return 'opencode.json';
+    if (this.fileContent('opencode.jsonc')) return 'opencode.jsonc';
+    return null;
+  }
+
+  globalConfigContent() {
+    const homeDir = os.homedir();
+    const globalPaths = [
+      path.join(homeDir, '.config', 'opencode', 'opencode.json'),
+      path.join(homeDir, '.config', 'opencode', 'opencode.jsonc'),
+    ];
+    for (const globalPath of globalPaths) {
+      try {
+        return fs.readFileSync(globalPath, 'utf8');
+      } catch {
+        // continue
+      }
+    }
+    return null;
+  }
+
+  agentsMdContent() {
+    const direct = this.fileContent('AGENTS.md');
+    if (direct) return direct;
+
+    // OpenCode fallback: CLAUDE.md if no AGENTS.md
+    const claudeMd = this.fileContent('CLAUDE.md');
+    if (claudeMd) return claudeMd;
+
+    return null;
+  }
+
+  agentsMdPath() {
+    if (this.fileContent('AGENTS.md')) return 'AGENTS.md';
+    if (this.fileContent('CLAUDE.md')) return 'CLAUDE.md';
+    return null;
+  }
+
+  hasAgentsMdAndClaudeMd() {
+    return Boolean(this.fileContent('AGENTS.md')) && Boolean(this.fileContent('CLAUDE.md'));
+  }
+
+  globalAgentsMdContent() {
+    const homeDir = os.homedir();
+    const paths = [
+      path.join(homeDir, '.config', 'opencode', 'AGENTS.md'),
+      path.join(homeDir, '.claude', 'CLAUDE.md'),
+    ];
+    for (const p of paths) {
+      try {
+        return fs.readFileSync(p, 'utf8');
+      } catch {
+        // continue
+      }
+    }
+    return null;
+  }
+
+  configJson() {
+    const content = this.configContent();
+    if (!content) {
+      return { ok: false, data: null, error: 'missing project config', source: this.configFileName() || 'opencode.json' };
+    }
+    const parsed = tryParseJsonc(content);
+    return { ...parsed, source: this.configFileName() };
+  }
+
+  globalConfigJson() {
+    const content = this.globalConfigContent();
+    if (!content) {
+      return { ok: false, data: null, error: 'missing global config', source: '~/.config/opencode/opencode.json' };
+    }
+    const parsed = tryParseJsonc(content);
+    return { ...parsed, source: '~/.config/opencode/opencode.json' };
+  }
+
+  configValue(dottedPath) {
+    // 6-level merge: project wins over global
+    const project = this.configJson();
+    if (project.ok) {
+      const projectValue = getValueByPath(project.data, dottedPath);
+      if (projectValue !== undefined) return projectValue;
+    }
+
+    const globalConfig = this.globalConfigJson();
+    if (globalConfig.ok) {
+      return getValueByPath(globalConfig.data, dottedPath);
+    }
+
+    return undefined;
+  }
+
+  permissions() {
+    const config = this.configJson();
+    if (!config.ok || !config.data) return {};
+    return config.data.permissions || {};
+  }
+
+  toolPermissions() {
+    const perms = this.permissions();
+    return perms.tools || {};
+  }
+
+  plugins() {
+    const config = this.configJson();
+    if (!config.ok || !config.data) return [];
+    return config.data.plugins || [];
+  }
+
+  pluginFiles() {
+    const pluginsDir = path.join(this.dir, '.opencode', 'plugins');
+    try {
+      return fs.readdirSync(pluginsDir).filter(f => /\.(js|ts|mjs)$/.test(f));
+    } catch {
+      return [];
+    }
+  }
+
+  tuiConfigContent() {
+    return this.fileContent('tui.json') || this.fileContent('tui.jsonc') ||
+      this.fileContent('.opencode/tui.json') || this.fileContent('.opencode/tui.jsonc');
+  }
+
+  tuiConfigJson() {
+    const content = this.tuiConfigContent();
+    if (!content) return { ok: false, data: null, error: 'missing tui config' };
+    return tryParseJsonc(content);
+  }
+
+  mcpServers() {
+    return this.configValue('mcp') || {};
+  }
+
+  customAgents() {
+    const config = this.configJson();
+    if (!config.ok || !config.data) return {};
+    return config.data.agents || {};
+  }
+
+  commandDirs() {
+    const commandsDir = path.join(this.dir, '.opencode', 'commands');
+    return listDirs(commandsDir).map(entry => entry.name);
+  }
+
+  commandFiles() {
+    const commandsDir = path.join(this.dir, '.opencode', 'commands');
+    try {
+      return fs.readdirSync(commandsDir).filter(f => /\.(md|yaml|yml)$/.test(f));
+    } catch {
+      return [];
+    }
+  }
+
+  skillDirs() {
+    const skillsDir = path.join(this.dir, '.opencode', 'commands');
+    return listDirs(skillsDir).map(entry => entry.name);
+  }
+
+  skillMetadata(name) {
+    return this.fileContent(path.join('.opencode', 'commands', name, 'SKILL.md'));
+  }
+
+  themeFiles() {
+    const themesDir = path.join(this.dir, '.opencode', 'themes');
+    try {
+      return fs.readdirSync(themesDir).filter(f => f.endsWith('.json'));
+    } catch {
+      return [];
+    }
+  }
+
+  instructionsArray() {
+    return this.configValue('instructions') || [];
+  }
+
+  workflowFiles() {
+    return this.dirFiles('.github/workflows')
+      .filter(file => /\.ya?ml$/i.test(file))
+      .map(file => path.join('.github', 'workflows', file).replace(/\\/g, '/'));
+  }
+
+  static isOpenCodeRepo(dir) {
+    try {
+      return fs.existsSync(path.join(dir, 'opencode.json')) ||
+        fs.existsSync(path.join(dir, 'opencode.jsonc')) ||
+        fs.existsSync(path.join(dir, '.opencode'));
+    } catch {
+      return false;
+    }
+  }
+}
+
+module.exports = {
+  OpenCodeProjectContext,
+  detectOpencodeVersion,
+};