@nerviq/cli 0.0.1 → 0.9.0-beta.1

package/src/windsurf/config-parser.js

@@ -0,0 +1,267 @@
+/**
+ * Windsurf config parser.
+ *
+ * Windsurf uses Markdown + YAML frontmatter for .windsurf/rules/*.md,
+ * and JSON for .windsurf/mcp.json and other config.
+ * Key difference from Cursor: NO MDC format — standard Markdown with YAML frontmatter.
+ * 4 activation modes: Always, Auto, Agent-Requested, Manual.
+ * 10K char rule limit per file.
+ * This module handles both formats with unified value extraction.
+ */
+
+// ─── JSON parsing ────────────────────────────────────────────────────────────
+
+function tryParseJson(content) {
+  try {
+    const data = JSON.parse(content);
+    return { ok: true, data, error: null };
+  } catch (error) {
+    return { ok: false, data: null, error: error.message };
+  }
+}
+
+// ─── YAML frontmatter parsing (Markdown files) ─────────────────────────────
+
+/**
+ * Parse a Windsurf rule file (YAML frontmatter delimited by --- + Markdown body).
+ * Returns { frontmatter: object|null, body: string, raw: string|null }
+ */
+function parseWindsurfRule(content) {
+  if (!content || typeof content !== 'string') {
+    return { frontmatter: null, body: content || '', raw: null };
+  }
+
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith('---')) {
+    return { frontmatter: null, body: content, raw: null };
+  }
+
+  const endIdx = trimmed.indexOf('---', 3);
+  if (endIdx === -1) {
+    return { frontmatter: null, body: content, raw: null };
+  }
+
+  const raw = trimmed.slice(3, endIdx).trim();
+  const body = trimmed.slice(endIdx + 3).trim();
+  const frontmatter = parseSimpleYaml(raw);
+
+  return { frontmatter, body, raw };
+}
+
+/**
+ * Minimal YAML parser for Windsurf rule frontmatter fields.
+ * Handles: key: value, key: [item1, item2], key: "quoted", booleans, numbers.
+ * Also handles multi-line array syntax (indented with -).
+ */
+function parseSimpleYaml(yamlStr) {
+  if (!yamlStr || typeof yamlStr !== 'string') return {};
+
+  const result = {};
+  const lines = yamlStr.split(/\r?\n/);
+  let currentKey = null;
+  let currentArray = null;
+
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine || trimmedLine.startsWith('#')) continue;
+
+    // Check for multi-line array item (  - "value")
+    if (currentKey && currentArray !== null && /^\s*-\s+/.test(line)) {
+      const itemValue = trimmedLine.slice(1).trim();
+      currentArray.push(stripQuotes(itemValue));
+      continue;
+    }
+
+    // If we were collecting an array, commit it
+    if (currentKey && currentArray !== null) {
+      result[currentKey] = currentArray;
+      currentKey = null;
+      currentArray = null;
+    }
+
+    const colonIdx = trimmedLine.indexOf(':');
+    if (colonIdx === -1) continue;
+
+    const key = trimmedLine.slice(0, colonIdx).trim();
+    let value = trimmedLine.slice(colonIdx + 1).trim();
+
+    if (!key) continue;
+
+    // Parse value
+    if (value === '') {
+      // Could be start of multi-line array
+      currentKey = key;
+      currentArray = [];
+    } else if (value.startsWith('[') && value.endsWith(']')) {
+      // Inline array: [item1, item2]
+      const inner = value.slice(1, -1).trim();
+      if (!inner) {
+        result[key] = [];
+      } else {
+        result[key] = inner.split(',').map(item => {
+          const t = item.trim();
+          return stripQuotes(t);
+        });
+      }
+    } else if ((value.startsWith('"') && value.endsWith('"')) ||
+               (value.startsWith("'") && value.endsWith("'"))) {
+      result[key] = value.slice(1, -1);
+    } else if (value === 'true') {
+      result[key] = true;
+    } else if (value === 'false') {
+      result[key] = false;
+    } else if (/^-?\d+$/.test(value)) {
+      result[key] = parseInt(value, 10);
+    } else if (/^-?\d+\.\d+$/.test(value)) {
+      result[key] = parseFloat(value);
+    } else {
+      result[key] = value;
+    }
+  }
+
+  // Commit any remaining array
+  if (currentKey && currentArray !== null) {
+    result[currentKey] = currentArray;
+  }
+
+  return result;
+}
+
+function stripQuotes(str) {
+  if ((str.startsWith('"') && str.endsWith('"')) ||
+      (str.startsWith("'") && str.endsWith("'"))) {
+    return str.slice(1, -1);
+  }
+  return str;
+}
+
+// ─── Windsurf rule type detection ───────────────────────────────────────────
+
+/**
+ * Determine the Windsurf rule activation mode from frontmatter fields.
+ *
+ * Windsurf 4 activation modes:
+ *   Always:           trigger: always
+ *   Auto:             trigger: auto, globs set
+ *   Agent-Requested:  trigger: agent_requested, description set
+ *   Manual:           trigger: manual (or no trigger field)
+ */
+function detectRuleType(frontmatter) {
+  if (!frontmatter) return 'manual';
+
+  const trigger = (frontmatter.trigger || '').toLowerCase().trim();
+
+  if (trigger === 'always') return 'always';
+  if (trigger === 'auto' || trigger === 'auto_attached') return 'auto';
+  if (trigger === 'agent_requested' || trigger === 'agent-requested') return 'agent-requested';
+  if (trigger === 'manual') return 'manual';
+
+  // Fallback heuristic based on fields
+  const hasGlobs = Array.isArray(frontmatter.globs)
+    ? frontmatter.globs.length > 0
+    : Boolean(frontmatter.globs);
+  const hasDescription = Boolean(frontmatter.description && String(frontmatter.description).trim());
+
+  if (hasGlobs) return 'auto';
+  if (hasDescription && !hasGlobs) return 'agent-requested';
+  return 'manual';
+}
+
+// ─── Value extraction ────────────────────────────────────────────────────────
+
+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;
+}
+
+// ─── Windsurf frontmatter validation ────────────────────────────────────────
+
+const VALID_WINDSURF_FIELDS = new Set(['trigger', 'description', 'globs', 'name']);
+
+/**
+ * Validate Windsurf rule file frontmatter.
+ * Returns { valid, errors, ruleType }.
+ */
+function validateWindsurfFrontmatter(frontmatter) {
+  if (!frontmatter) return { valid: false, errors: ['No frontmatter found'], ruleType: 'manual' };
+
+  const errors = [];
+
+  for (const key of Object.keys(frontmatter)) {
+    if (!VALID_WINDSURF_FIELDS.has(key)) {
+      errors.push(`Unknown Windsurf frontmatter field: "${key}"`);
+    }
+  }
+
+  // Validate trigger field
+  const validTriggers = ['always', 'auto', 'auto_attached', 'agent_requested', 'agent-requested', 'manual'];
+  if (frontmatter.trigger && !validTriggers.includes(String(frontmatter.trigger).toLowerCase().trim())) {
+    errors.push(`Invalid trigger value: "${frontmatter.trigger}". Must be one of: always, auto, agent_requested, manual`);
+  }
+
+  // Validate globs is an array if present
+  if (frontmatter.globs !== undefined && !Array.isArray(frontmatter.globs) && typeof frontmatter.globs !== 'string') {
+    errors.push('globs must be a string or array of strings');
+  }
+
+  // Warn on 10K char limit
+  const ruleType = detectRuleType(frontmatter);
+
+  return { valid: errors.length === 0, errors, ruleType };
+}
+
+// ─── MCP config validation ──────────────────────────────────────────────────
+
+/**
+ * Count total MCP tools across all servers.
+ * Windsurf has team-level MCP whitelisting.
+ */
+function countMcpTools(mcpData) {
+  if (!mcpData || !mcpData.mcpServers) return 0;
+
+  let total = 0;
+  for (const server of Object.values(mcpData.mcpServers)) {
+    // Each server exposes tools; estimate ~5 per server if no explicit count
+    const toolCount = server.tools ? Object.keys(server.tools).length : 5;
+    total += toolCount;
+  }
+  return total;
+}
+
+/**
+ * Validate MCP env vars use proper syntax (not hardcoded secrets).
+ */
+function validateMcpEnvVars(mcpData) {
+  if (!mcpData || !mcpData.mcpServers) return { valid: true, hardcodedVars: [] };
+
+  const hardcodedVars = [];
+  for (const [serverName, config] of Object.entries(mcpData.mcpServers)) {
+    if (!config.env) continue;
+    for (const [key, value] of Object.entries(config.env)) {
+      if (typeof value === 'string' && !value.startsWith('${env:') && /key|token|secret|password|api/i.test(key)) {
+        hardcodedVars.push({ server: serverName, key, value: '[REDACTED]' });
+      }
+    }
+  }
+
+  return { valid: hardcodedVars.length === 0, hardcodedVars };
+}
+
+module.exports = {
+  tryParseJson,
+  parseWindsurfRule,
+  parseSimpleYaml,
+  detectRuleType,
+  getValueByPath,
+  validateWindsurfFrontmatter,
+  countMcpTools,
+  validateMcpEnvVars,
+};

package/src/windsurf/context.js

@@ -0,0 +1,249 @@
+/**
+ * Windsurf project context.
+ *
+ * Extends the shared ProjectContext with Windsurf-specific file lookups:
+ * - .windsurf/rules/*.md (Markdown + YAML frontmatter, NOT MDC)
+ * - .windsurfrules (legacy, flat file)
+ * - .windsurf/mcp.json (MCP server config with team whitelist)
+ * - .windsurf/workflows/*.md (slash commands / workflows)
+ * - .windsurf/memories/ (team-syncable memories)
+ * - .cascadeignore (gitignore-like for Cascade agent)
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { ProjectContext } = require('../context');
+const { tryParseJson, parseWindsurfRule, detectRuleType, getValueByPath } = require('./config-parser');
+
+function listFiles(fullPath, filter) {
+  try {
+    const entries = fs.readdirSync(fullPath).filter(f => !f.startsWith('.'));
+    return filter ? entries.filter(filter) : entries;
+  } catch {
+    return [];
+  }
+}
+
+class WindsurfProjectContext extends ProjectContext {
+
+  // ─── Rules (.windsurf/rules/*.md) ──────────────────────────────────────
+
+  /**
+   * List all .md rule files in .windsurf/rules/.
+   * Returns array of { name, path, frontmatter, body, ruleType }.
+   *
+   * Windsurf uses Markdown + YAML frontmatter (NOT MDC like Cursor).
+   * 4 activation modes: Always, Auto, Agent-Requested, Manual.
+   * 10K char limit per rule file.
+   */
+  windsurfRules() {
+    const dir = path.join(this.dir, '.windsurf', 'rules');
+    const files = listFiles(dir, f => f.endsWith('.md'));
+    return files.map(f => {
+      const relPath = `.windsurf/rules/${f}`;
+      const content = this.fileContent(relPath);
+      if (!content) return null;
+      const parsed = parseWindsurfRule(content);
+      const ruleType = detectRuleType(parsed.frontmatter);
+      return {
+        name: f.replace('.md', ''),
+        path: relPath,
+        frontmatter: parsed.frontmatter,
+        body: parsed.body,
+        ruleType,
+        charCount: (content || '').length,
+        overLimit: (content || '').length > 10000,
+      };
+    }).filter(Boolean);
+  }
+
+  /**
+   * Get rules filtered by type.
+   */
+  alwaysRules() {
+    return this.windsurfRules().filter(r => r.ruleType === 'always');
+  }
+
+  autoRules() {
+    return this.windsurfRules().filter(r => r.ruleType === 'auto');
+  }
+
+  agentRequestedRules() {
+    return this.windsurfRules().filter(r => r.ruleType === 'agent-requested');
+  }
+
+  manualRules() {
+    return this.windsurfRules().filter(r => r.ruleType === 'manual');
+  }
+
+  // ─── Legacy .windsurfrules ────────────────────────────────────────────
+
+  /**
+   * .windsurfrules content (deprecated).
+   */
+  legacyWindsurfrules() {
+    return this.fileContent('.windsurfrules');
+  }
+
+  hasLegacyRules() {
+    return Boolean(this.legacyWindsurfrules());
+  }
+
+  // ─── MCP config (.windsurf/mcp.json) ──────────────────────────────────
+
+  /**
+   * .windsurf/mcp.json parsed.
+   * Windsurf MCP format: { mcpServers: { name: { command, args, env } } }
+   * Supports team-level whitelist.
+   */
+  mcpConfig() {
+    const content = this.fileContent('.windsurf/mcp.json');
+    if (!content) {
+      return { ok: false, data: null, error: 'missing .windsurf/mcp.json', source: '.windsurf/mcp.json' };
+    }
+    const parsed = tryParseJson(content);
+    return { ...parsed, source: '.windsurf/mcp.json' };
+  }
+
+  /**
+   * Global MCP config (~/.windsurf/mcp.json).
+   */
+  globalMcpConfig() {
+    const homeDir = os.homedir();
+    const globalPath = path.join(homeDir, '.windsurf', 'mcp.json');
+    try {
+      const content = fs.readFileSync(globalPath, 'utf8');
+      const parsed = tryParseJson(content);
+      return { ...parsed, source: globalPath };
+    } catch {
+      return { ok: false, data: null, error: 'missing global mcp.json', source: globalPath };
+    }
+  }
+
+  /**
+   * MCP servers from .windsurf/mcp.json.
+   */
+  mcpServers() {
+    const result = this.mcpConfig();
+    if (!result.ok || !result.data) return {};
+    return result.data.mcpServers || {};
+  }
+
+  /**
+   * Count total MCP tools across all servers.
+   */
+  totalMcpTools() {
+    const servers = this.mcpServers();
+    let total = 0;
+    for (const server of Object.values(servers)) {
+      const toolCount = server.tools ? Object.keys(server.tools).length : 5;
+      total += toolCount;
+    }
+    return total;
+  }
+
+  // ─── Workflows (.windsurf/workflows/*.md) ─────────────────────────────
+
+  /**
+   * Workflow files (slash commands).
+   * Windsurf workflows are Markdown files that define slash commands.
+   */
+  workflowFiles() {
+    const dir = path.join(this.dir, '.windsurf', 'workflows');
+    return listFiles(dir, f => f.endsWith('.md'))
+      .map(f => `.windsurf/workflows/${f}`);
+  }
+
+  // ─── Memories (.windsurf/memories/) ───────────────────────────────────
+
+  /**
+   * Memory files (team-syncable persistent context).
+   */
+  memoryFiles() {
+    const dir = path.join(this.dir, '.windsurf', 'memories');
+    return listFiles(dir, f => f.endsWith('.md') || f.endsWith('.json'));
+  }
+
+  memoryContents() {
+    const dir = path.join(this.dir, '.windsurf', 'memories');
+    const files = this.memoryFiles();
+    return files.map(f => {
+      const relPath = `.windsurf/memories/${f}`;
+      const content = this.fileContent(relPath);
+      return { name: f, path: relPath, content };
+    }).filter(item => item.content);
+  }
+
+  // ─── Cascadeignore (.cascadeignore) ───────────────────────────────────
+
+  /**
+   * .cascadeignore content (gitignore-like for Cascade agent).
+   */
+  cascadeignoreContent() {
+    return this.fileContent('.cascadeignore');
+  }
+
+  hasCascadeignore() {
+    return Boolean(this.cascadeignoreContent());
+  }
+
+  // ─── VS Code compat (.vscode/settings.json) ──────────────────────────
+
+  vscodeSettings() {
+    const content = this.fileContent('.vscode/settings.json');
+    if (!content) {
+      return { ok: false, data: null, error: 'missing .vscode/settings.json', source: '.vscode/settings.json' };
+    }
+    const parsed = tryParseJson(content);
+    return { ...parsed, source: '.vscode/settings.json' };
+  }
+
+  // ─── CI Workflow files ────────────────────────────────────────────────
+
+  ciWorkflowFiles() {
+    const dir = path.join(this.dir, '.github', 'workflows');
+    return listFiles(dir, f => f.endsWith('.yml') || f.endsWith('.yaml'))
+      .map(f => `.github/workflows/${f}`);
+  }
+
+  // ─── Surface detection ────────────────────────────────────────────────
+
+  /**
+   * Detect which Windsurf surfaces are configured.
+   * Windsurf has NO background agents (unlike Cursor).
+   */
+  detectSurfaces() {
+    const foreground = Boolean(
+      this.windsurfRules().length > 0 ||
+      this.legacyWindsurfrules() ||
+      this.mcpConfig().ok
+    );
+    const workflows = this.workflowFiles().length > 0;
+    const memories = this.memoryFiles().length > 0;
+    const cascadeignore = this.hasCascadeignore();
+
+    return { foreground, workflows, memories, cascadeignore };
+  }
+
+  // ─── Static detection ─────────────────────────────────────────────────
+
+  static isWindsurfRepo(dir) {
+    try {
+      return fs.existsSync(path.join(dir, '.windsurf')) ||
+        fs.existsSync(path.join(dir, '.windsurfrules'));
+    } catch {
+      return false;
+    }
+  }
+
+  // ─── Stack detection (reuse shared) ───────────────────────────────────
+
+  detectStacks(STACKS) {
+    return super.detectStacks(STACKS);
+  }
+}
+
+module.exports = {
+  WindsurfProjectContext,
+};