@nerviq/cli 0.0.1 → 0.9.0-beta.2

package/src/codex/config-parser.js

@@ -0,0 +1,183 @@
+const COMMENT_MARKER = '#';
+
+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 === COMMENT_MARKER && !inSingle && !inDouble) {
+      return line.slice(0, i).trimEnd();
+    }
+  }
+
+  return line;
+}
+
+function assignPath(target, pathParts, value) {
+  let cursor = target;
+  for (let i = 0; i < pathParts.length - 1; i++) {
+    const key = pathParts[i];
+    if (!cursor[key] || typeof cursor[key] !== 'object' || Array.isArray(cursor[key])) {
+      cursor[key] = {};
+    }
+    cursor = cursor[key];
+  }
+  cursor[pathParts[pathParts.length - 1]] = value;
+}
+
+function parseString(value) {
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    return value.slice(1, -1);
+  }
+  return null;
+}
+
+function splitInlineItems(value, separator = ',') {
+  const items = [];
+  let current = '';
+  let inSingle = false;
+  let inDouble = false;
+  let depth = 0;
+
+  for (let i = 0; i < value.length; i++) {
+    const char = value[i];
+    const prev = i > 0 ? value[i - 1] : '';
+
+    if (char === "'" && !inDouble && prev !== '\\') {
+      inSingle = !inSingle;
+    } else if (char === '"' && !inSingle && prev !== '\\') {
+      inDouble = !inDouble;
+    } else if (!inSingle && !inDouble) {
+      if (char === '[' || char === '{') depth++;
+      if (char === ']' || char === '}') depth--;
+      if (char === separator && depth === 0) {
+        items.push(current.trim());
+        current = '';
+        continue;
+      }
+    }
+
+    current += char;
+  }
+
+  if (current.trim()) {
+    items.push(current.trim());
+  }
+
+  return items;
+}
+
+function parseValue(rawValue) {
+  const value = rawValue.trim();
+
+  const asString = parseString(value);
+  if (asString !== null) return asString;
+
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  if (/^-?\d+$/.test(value)) return Number.parseInt(value, 10);
+  if (/^-?\d+\.\d+$/.test(value)) return Number.parseFloat(value);
+
+  if (value.startsWith('[') && value.endsWith(']')) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner) return [];
+    return splitInlineItems(inner).map(parseValue);
+  }
+
+  if (value.startsWith('{') && value.endsWith('}')) {
+    const inner = value.slice(1, -1).trim();
+    const result = {};
+    if (!inner) return result;
+
+    for (const entry of splitInlineItems(inner)) {
+      const idx = entry.indexOf('=');
+      if (idx === -1) {
+        throw new Error(`Invalid inline table entry: ${entry}`);
+      }
+      const key = entry.slice(0, idx).trim();
+      const entryValue = entry.slice(idx + 1).trim();
+      assignPath(result, key.split('.').map(part => part.trim()).filter(Boolean), parseValue(entryValue));
+    }
+    return result;
+  }
+
+  return value;
+}
+
+function parseToml(content) {
+  const root = {};
+  let currentSection = [];
+
+  const lines = content.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+    const line = stripInlineComment(rawLine).trim();
+    if (!line) continue;
+
+    if (line.startsWith('[') && line.endsWith(']')) {
+      const sectionName = line.slice(1, -1).trim();
+      if (!sectionName) {
+        throw new Error(`Line ${i + 1}: empty section header`);
+      }
+      currentSection = sectionName.split('.').map(part => part.trim()).filter(Boolean);
+      assignPath(root, currentSection, {});
+      continue;
+    }
+
+    const eqIndex = line.indexOf('=');
+    if (eqIndex === -1) {
+      throw new Error(`Line ${i + 1}: expected key = value`);
+    }
+
+    const key = line.slice(0, eqIndex).trim();
+    const rawValue = line.slice(eqIndex + 1).trim();
+    if (!key || !rawValue) {
+      throw new Error(`Line ${i + 1}: invalid key/value pair`);
+    }
+
+    const keyPath = key.split('.').map(part => part.trim()).filter(Boolean);
+    assignPath(root, [...currentSection, ...keyPath], parseValue(rawValue));
+  }
+
+  return root;
+}
+
+function tryParseToml(content) {
+  try {
+    return { ok: true, data: parseToml(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 = {
+  parseToml,
+  tryParseToml,
+  getValueByPath,
+};

package/src/codex/context.js

@@ -0,0 +1,221 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { ProjectContext } = require('../context');
+const { tryParseToml, getValueByPath } = require('./config-parser');
+
+let codexVersionCache = null;
+
+function detectCodexVersion() {
+  if (codexVersionCache !== null) {
+    return codexVersionCache;
+  }
+
+  try {
+    const result = spawnSync('codex', ['--version'], { encoding: 'utf8' });
+    const output = `${result.stdout || ''} ${result.stderr || ''}`.trim();
+    const match = output.match(/codex-cli\s+([^\s]+)/i);
+    codexVersionCache = match ? match[1] : (output || null);
+    return codexVersionCache;
+  } catch {
+    codexVersionCache = null;
+    return null;
+  }
+}
+
+function listDirs(fullPath) {
+  try {
+    return fs.readdirSync(fullPath, { withFileTypes: true }).filter(entry => entry.isDirectory());
+  } catch {
+    return [];
+  }
+}
+
+class CodexProjectContext extends ProjectContext {
+  configContent() {
+    return this.fileContent('.codex/config.toml');
+  }
+
+  globalConfigContent() {
+    const homeDir = os.homedir();
+    const globalPath = path.join(homeDir, '.codex', 'config.toml');
+    try {
+      return fs.readFileSync(globalPath, 'utf8');
+    } catch {
+      return null;
+    }
+  }
+
+  agentsMdContent() {
+    const direct = this.fileContent('AGENTS.md');
+    if (direct) return direct;
+
+    const fallbackNames = this.projectDocFallbackFilenames();
+    for (const fileName of fallbackNames) {
+      const content = this.fileContent(fileName);
+      if (content) return content;
+    }
+
+    return null;
+  }
+
+  agentsMdPath() {
+    if (this.fileContent('AGENTS.md')) return 'AGENTS.md';
+    const fallbackNames = this.projectDocFallbackFilenames();
+    for (const fileName of fallbackNames) {
+      if (this.fileContent(fileName)) return fileName;
+    }
+    return null;
+  }
+
+  agentsOverrideMdContent() {
+    return this.fileContent('AGENTS.override.md');
+  }
+
+  hasAgentsOverride() {
+    return Boolean(this.agentsOverrideMdContent());
+  }
+
+  configToml() {
+    const content = this.fileContent('.codex/config.toml');
+    if (!content) {
+      return { ok: false, data: null, error: 'missing project config', source: '.codex/config.toml' };
+    }
+    const parsed = tryParseToml(content);
+    return { ...parsed, source: '.codex/config.toml' };
+  }
+
+  globalConfigToml() {
+    const homeDir = os.homedir();
+    const globalPath = path.join(homeDir, '.codex', 'config.toml');
+    try {
+      const content = fs.readFileSync(globalPath, 'utf8');
+      const parsed = tryParseToml(content);
+      return { ...parsed, source: globalPath };
+    } catch {
+      return { ok: false, data: null, error: 'missing global config', source: globalPath };
+    }
+  }
+
+  configValue(dottedPath) {
+    const project = this.configToml();
+    if (project.ok) {
+      const projectValue = getValueByPath(project.data, dottedPath);
+      if (projectValue !== undefined) return projectValue;
+    }
+
+    const globalConfig = this.globalConfigToml();
+    if (globalConfig.ok) {
+      return getValueByPath(globalConfig.data, dottedPath);
+    }
+
+    return undefined;
+  }
+
+  projectDocFallbackFilenames() {
+    const configured = this.configValue('project_doc_fallback_filenames');
+    if (Array.isArray(configured) && configured.length > 0) {
+      return configured.filter(item => typeof item === 'string' && item.trim()).map(item => item.trim());
+    }
+    return [];
+  }
+
+  hooksJson() {
+    return this.jsonFile('.codex/hooks.json');
+  }
+
+  hooksJsonContent() {
+    return this.fileContent('.codex/hooks.json');
+  }
+
+  hookFiles() {
+    const hooksDir = path.join(this.dir, '.codex', 'hooks');
+    return listDirs(hooksDir).map(entry => entry.name);
+  }
+
+  skillDirs() {
+    const skillsDir = path.join(this.dir, '.agents', 'skills');
+    return listDirs(skillsDir).map(entry => entry.name);
+  }
+
+  skillMetadata(name) {
+    return this.fileContent(path.join('.agents', 'skills', name, 'SKILL.md'));
+  }
+
+  customAgentFiles() {
+    return this.dirFiles('.codex/agents').filter(file => file.endsWith('.toml'));
+  }
+
+  customAgentConfig(fileName) {
+    const content = this.fileContent(path.join('.codex', 'agents', fileName));
+    if (!content) return { ok: false, data: null, error: 'missing agent config' };
+    return tryParseToml(content);
+  }
+
+  mcpServers() {
+    return this.configValue('mcp_servers') || {};
+  }
+
+  workflowFiles() {
+    return this.dirFiles('.github/workflows')
+      .filter(file => /\.ya?ml$/i.test(file))
+      .map(file => path.join('.github', 'workflows', file).replace(/\\/g, '/'));
+  }
+
+  ruleFiles() {
+    const candidateDirs = ['codex/rules', '.codex/rules'];
+    const files = [];
+
+    for (const dirPath of candidateDirs) {
+      for (const file of this.dirFiles(dirPath)) {
+        if (file.startsWith('.')) continue;
+        files.push(path.join(dirPath, file).replace(/\\/g, '/'));
+      }
+    }
+
+    return files;
+  }
+
+  isProjectTrusted() {
+    const content = this.globalConfigContent();
+    if (!content) return false;
+
+    const resolved = path.resolve(this.dir);
+    const variants = new Set([
+      resolved,
+      resolved.replace(/\\/g, '/'),
+      resolved.replace(/\//g, '\\'),
+      resolved.replace(/\\/g, '\\\\'),
+    ]);
+
+    for (const variant of variants) {
+      const escaped = variant.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const patterns = [
+        new RegExp(`["']${escaped}["'][\\s\\S]{0,220}?trust_level\\s*=\\s*["']trusted["']`, 'i'),
+        new RegExp(`trust_level\\s*=\\s*["']trusted["'][\\s\\S]{0,220}?["']${escaped}["']`, 'i'),
+        new RegExp(`projects[\\s\\S]{0,1200}?["']${escaped}["'][\\s\\S]{0,220}?trust_level\\s*=\\s*["']trusted["']`, 'i'),
+      ];
+      if (patterns.some((pattern) => pattern.test(content))) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  static isCodexRepo(dir) {
+    try {
+      return fs.existsSync(path.join(dir, 'AGENTS.md')) ||
+        fs.existsSync(path.join(dir, '.codex')) ||
+        fs.existsSync(path.join(dir, '.agents'));
+    } catch {
+      return false;
+    }
+  }
+}
+
+module.exports = {
+  CodexProjectContext,
+  detectCodexVersion,
+};