@ktpartners/dgs-platform 2.6.2

package/deliver-great-systems/bin/lib/config.cjs

@@ -0,0 +1,417 @@
+/**
+ * Config — Planning config CRUD operations
+ *
+ * Uses getConfigPath(cwd, mode) for all config file path resolution:
+ *   - 'read' mode: prefers dgs.config.json, falls back to config.json (dual-read)
+ *   - 'write' mode: always targets dgs.config.json (write-forward migration)
+ *
+ * Zero hardcoded .planning/config.json paths — all resolved via getPlanningRoot.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { output, error } = require('./core.cjs');
+const { getPlanningRoot } = require('./paths.cjs');
+
+const VALID_CONFIG_KEYS = new Set([
+  'mode', 'granularity', 'parallelization', 'commit_docs', 'model_profile',
+  'search_gitignored', 'brave_search',
+  'workflow.research', 'workflow.plan_check', 'workflow.verifier',
+  'workflow.nyquist_validation', 'workflow.ui_phase', 'workflow.ui_safety_gate',
+  'workflow._auto_chain_active', 'workflow.discipline',
+  'git.base_branch', 'git.branching_strategy', 'git.phase_branch_template', 'git.milestone_branch_template',
+  'planning.commit_docs', 'planning.search_gitignored',
+]);
+
+/**
+ * Resolve the config file path for the given cwd and mode.
+ *
+ * @param {string} cwd - Working directory
+ * @param {'read'|'write'} mode - 'read' for dual-check (dgs.config.json first, config.json fallback),
+ *                                  'write' for always dgs.config.json
+ * @returns {string} Absolute path to the config file
+ */
+function getConfigPath(cwd, mode) {
+  const root = getPlanningRoot(cwd);
+  const newPath = path.join(root, 'dgs.config.json');
+  if (mode === 'write') return newPath;
+  // Read mode: prefer dgs.config.json, fall back to config.json
+  if (fs.existsSync(newPath)) return newPath;
+  const legacyPath = path.join(root, 'config.json');
+  if (fs.existsSync(legacyPath)) return legacyPath;
+  return newPath; // default when neither exists
+}
+
+function cmdConfigEnsureSection(cwd, raw) {
+  const writePath = getConfigPath(cwd, 'write');
+  const parentDir = path.dirname(writePath);
+
+  // Ensure parent directory exists
+  try {
+    if (!fs.existsSync(parentDir)) {
+      fs.mkdirSync(parentDir, { recursive: true });
+    }
+  } catch (err) {
+    error('Failed to create config directory: ' + err.message);
+  }
+
+  // Check if config already exists (either dgs.config.json or legacy config.json)
+  const readPath = getConfigPath(cwd, 'read');
+  if (fs.existsSync(readPath)) {
+    const result = { created: false, reason: 'already_exists' };
+    output(result, raw, 'exists');
+    return;
+  }
+
+  // Detect Brave Search API key availability
+  const homedir = require('os').homedir();
+  const braveKeyFile = path.join(homedir, '.dgs', 'brave_api_key');
+  const hasBraveSearch = !!(process.env.BRAVE_API_KEY || fs.existsSync(braveKeyFile));
+
+  // Load user-level defaults from ~/.dgs/defaults.json if available
+  const globalDefaultsPath = path.join(homedir, '.dgs', 'defaults.json');
+  let userDefaults = {};
+  try {
+    if (fs.existsSync(globalDefaultsPath)) {
+      userDefaults = JSON.parse(fs.readFileSync(globalDefaultsPath, 'utf-8'));
+      // Migrate deprecated "depth" key to "granularity"
+      if ('depth' in userDefaults && !('granularity' in userDefaults)) {
+        const depthToGranularity = { quick: 'coarse', standard: 'standard', comprehensive: 'fine' };
+        userDefaults.granularity = depthToGranularity[userDefaults.depth] || userDefaults.depth;
+        delete userDefaults.depth;
+        try { fs.writeFileSync(globalDefaultsPath, JSON.stringify(userDefaults, null, 2), 'utf-8'); } catch {}
+      }
+    }
+  } catch (err) {
+    // Ignore malformed global defaults, fall back to hardcoded
+  }
+
+  // Create default config (user-level defaults override hardcoded defaults)
+  const hardcoded = {
+    model_profile: 'balanced',
+    commit_docs: true,
+    search_gitignored: false,
+    branching_strategy: 'none',
+    phase_branch_template: 'dgs/{project}/phase-{phase}-{slug}',
+    milestone_branch_template: 'dgs/{project}/{milestone}-{slug}',
+    base_branch: 'main',
+    workflow: {
+      research: true,
+      plan_check: true,
+      verifier: true,
+      nyquist_validation: true,
+      discipline: true,
+    },
+    parallelization: true,
+    brave_search: hasBraveSearch,
+  };
+  const defaults = {
+    ...hardcoded,
+    ...userDefaults,
+    workflow: { ...hardcoded.workflow, ...(userDefaults.workflow || {}) },
+  };
+
+  try {
+    fs.writeFileSync(writePath, JSON.stringify(defaults, null, 2), 'utf-8');
+    const result = { created: true, path: path.relative(cwd, writePath) || writePath };
+    output(result, raw, 'created');
+  } catch (err) {
+    error('Failed to create dgs.config.json: ' + err.message);
+  }
+}
+
+function cmdConfigSet(cwd, keyPath, value, raw) {
+  if (!keyPath) {
+    error('Usage: config-set <key.path> <value>');
+  }
+
+  if (!VALID_CONFIG_KEYS.has(keyPath)) {
+    error(`Unknown config key: "${keyPath}". Valid keys: ${[...VALID_CONFIG_KEYS].sort().join(', ')}`);
+  }
+
+  // Parse value (handle booleans and numbers)
+  let parsedValue = value;
+  if (value === 'true') parsedValue = true;
+  else if (value === 'false') parsedValue = false;
+  else if (!isNaN(value) && value !== '') parsedValue = Number(value);
+
+  // Load existing config from read path (may be legacy config.json)
+  const readPath = getConfigPath(cwd, 'read');
+  let config = {};
+  try {
+    if (fs.existsSync(readPath)) {
+      config = JSON.parse(fs.readFileSync(readPath, 'utf-8'));
+    }
+  } catch (err) {
+    error('Failed to read config: ' + err.message);
+  }
+
+  // Set nested value using dot notation (e.g., "workflow.research")
+  const keys = keyPath.split('.');
+  let current = config;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (current[key] === undefined || typeof current[key] !== 'object') {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = parsedValue;
+
+  // Write to dgs.config.json (write-forward migration)
+  const writePath = getConfigPath(cwd, 'write');
+  try {
+    fs.writeFileSync(writePath, JSON.stringify(config, null, 2), 'utf-8');
+    const result = { updated: true, key: keyPath, value: parsedValue };
+    output(result, raw, `${keyPath}=${parsedValue}`);
+  } catch (err) {
+    error('Failed to write dgs.config.json: ' + err.message);
+  }
+}
+
+function cmdConfigGet(cwd, keyPath, raw) {
+  if (!keyPath) {
+    error('Usage: config-get <key.path>');
+  }
+
+  const readPath = getConfigPath(cwd, 'read');
+  let config = {};
+  try {
+    if (fs.existsSync(readPath)) {
+      config = JSON.parse(fs.readFileSync(readPath, 'utf-8'));
+    } else {
+      error('No config file found at ' + readPath);
+    }
+  } catch (err) {
+    if (err.message.startsWith('No config file')) throw err;
+    error('Failed to read config: ' + err.message);
+  }
+
+  // Traverse dot-notation path (e.g., "workflow.auto_advance")
+  const keys = keyPath.split('.');
+  let current = config;
+  for (const key of keys) {
+    if (current === undefined || current === null || typeof current !== 'object') {
+      error(`Key not found: ${keyPath}`);
+    }
+    current = current[key];
+  }
+
+  if (current === undefined) {
+    error(`Key not found: ${keyPath}`);
+  }
+
+  output(current, raw, String(current));
+}
+
+/**
+ * Programmatically set a config field. Uses same dot-notation as cmdConfigSet.
+ * Does NOT call output()/process.exit() — returns the updated config.
+ *
+ * Reads from legacy config.json if it exists, writes to dgs.config.json (auto-migration).
+ *
+ * @param {string} cwd - Working directory
+ * @param {string} keyPath - Dot-notation key (e.g., "product_name" or "workflow.research")
+ * @param {*} value - Value to set
+ * @returns {object} Updated config object
+ */
+function writeConfigField(cwd, keyPath, value) {
+  const readPath = getConfigPath(cwd, 'read');
+  let config = {};
+  try {
+    if (fs.existsSync(readPath)) {
+      config = JSON.parse(fs.readFileSync(readPath, 'utf-8'));
+    }
+  } catch {
+    // Start with empty config if parse fails
+  }
+
+  const keys = keyPath.split('.');
+  let current = config;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (current[key] === undefined || typeof current[key] !== 'object') {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+
+  const writePath = getConfigPath(cwd, 'write');
+  fs.writeFileSync(writePath, JSON.stringify(config, null, 2), 'utf-8');
+  return config;
+}
+
+/**
+ * Get the path to review-keys.json in the planning root.
+ *
+ * @param {string} cwd - Working directory
+ * @returns {string} Absolute path to review-keys.json
+ */
+function getReviewKeysPath(cwd) {
+  return path.join(getPlanningRoot(cwd), 'review-keys.json');
+}
+
+/**
+ * Load review configuration from review-keys.json.
+ * Reads from review-keys.json in the planning root, applies defaults for missing fields,
+ * resolves $ENV_VAR references in api_key values.
+ *
+ * @param {string} cwd - Working directory
+ * @returns {object} { reviewers: { openai: {api_key, model}, gemini: {api_key, model} }, max_rounds, has_any_key }
+ */
+function loadReviewConfig(cwd) {
+  const reviewKeysPath = getReviewKeysPath(cwd);
+
+  const defaults = {
+    openai: { api_key: null, model: 'gpt-5-mini' },
+    gemini: { api_key: null, model: 'gemini-2.5-flash' },
+    max_rounds: 3,
+  };
+
+  let review = {};
+  try {
+    if (fs.existsSync(reviewKeysPath)) {
+      review = JSON.parse(fs.readFileSync(reviewKeysPath, 'utf-8'));
+    }
+  } catch {
+    // If review-keys.json is unreadable/malformed, return defaults
+  }
+
+  // Build per-reviewer config with defaults
+  const resolveKey = (key) => {
+    if (!key) return null;
+    if (typeof key === 'string' && key.startsWith('$')) {
+      const envVal = process.env[key.slice(1)];
+      return envVal || null;
+    }
+    return key;
+  };
+
+  const openaiSection = review.openai || {};
+  const geminiSection = review.gemini || {};
+
+  const reviewers = {
+    openai: {
+      api_key: resolveKey(openaiSection.api_key) || defaults.openai.api_key,
+      model: openaiSection.model || defaults.openai.model,
+    },
+    gemini: {
+      api_key: resolveKey(geminiSection.api_key) || defaults.gemini.api_key,
+      model: geminiSection.model || defaults.gemini.model,
+    },
+  };
+
+  const max_rounds = review.max_rounds != null ? review.max_rounds : defaults.max_rounds;
+  const has_any_key = !!(reviewers.openai.api_key || reviewers.gemini.api_key);
+
+  return { reviewers, max_rounds, has_any_key };
+}
+
+/**
+ * Check if review-keys.json needs .gitignore protection.
+ * Returns whether review-keys.json exists with non-empty keys and whether .gitignore covers it.
+ *
+ * @param {string} cwd - Working directory
+ * @returns {object} { needs_gitignore: boolean, has_review_keys: boolean }
+ */
+function checkConfigGitignore(cwd) {
+  const reviewKeysPath = getReviewKeysPath(cwd);
+  const gitignorePath = path.join(cwd, '.gitignore');
+
+  // Check if review-keys.json exists with non-empty api_key values
+  let has_review_keys = false;
+  try {
+    if (fs.existsSync(reviewKeysPath)) {
+      const review = JSON.parse(fs.readFileSync(reviewKeysPath, 'utf-8'));
+      const openaiKey = review.openai && review.openai.api_key;
+      const geminiKey = review.gemini && review.gemini.api_key;
+      has_review_keys = (typeof openaiKey === 'string' && openaiKey !== '') ||
+                        (typeof geminiKey === 'string' && geminiKey !== '');
+    }
+  } catch {
+    // If review-keys.json unreadable, treat as no review keys
+  }
+
+  if (!has_review_keys) {
+    return { needs_gitignore: false, has_review_keys: false };
+  }
+
+  // Check if .gitignore includes review-keys.json
+  let gitignoreCoversReviewKeys = false;
+  try {
+    if (fs.existsSync(gitignorePath)) {
+      const content = fs.readFileSync(gitignorePath, 'utf-8');
+      const lines = content.split('\n').map((l) => l.trim());
+      gitignoreCoversReviewKeys = lines.some(
+        (line) =>
+          line === 'review-keys.json' ||
+          line === '.planning/review-keys.json'
+      );
+    }
+  } catch {
+    // If .gitignore unreadable, treat as not covered
+  }
+
+  return {
+    needs_gitignore: !gitignoreCoversReviewKeys,
+    has_review_keys,
+  };
+}
+
+/**
+ * Ensure config files and review-keys.json are in .gitignore.
+ * Appends entries for dgs.config.json, config.json, and review-keys.json if not already present.
+ *
+ * @param {string} cwd - Working directory
+ * @returns {object} { added: boolean, reason?: string }
+ */
+function ensureConfigGitignored(cwd) {
+  const gitignorePath = path.join(cwd, '.gitignore');
+
+  let content = '';
+  try {
+    if (fs.existsSync(gitignorePath)) {
+      content = fs.readFileSync(gitignorePath, 'utf-8');
+    }
+  } catch {
+    // If unreadable, start fresh
+  }
+
+  // Check if already present (either legacy or new name)
+  const lines = content.split('\n').map((l) => l.trim());
+  const hasLegacy = lines.some((line) => line === '.planning/config.json');
+  const hasNew = lines.some((line) => line === '.planning/dgs.config.json' || line === 'dgs.config.json');
+  const hasReviewKeys = lines.some((line) => line === 'review-keys.json' || line === '.planning/review-keys.json');
+
+  if (hasLegacy && hasNew && hasReviewKeys) {
+    return { added: false, reason: 'already_present' };
+  }
+
+  // Append missing entries
+  let entry = '';
+  if (!hasNew || !hasLegacy) {
+    entry += '\n# DGS config (contains API keys)\n';
+    if (!hasNew) entry += 'dgs.config.json\n';
+    if (!hasLegacy) entry += '.planning/config.json\n';
+  }
+  if (!hasReviewKeys) {
+    entry += '\n# DGS review keys (contains API keys)\n';
+    entry += 'review-keys.json\n';
+    entry += '.planning/review-keys.json\n';
+  }
+  fs.writeFileSync(gitignorePath, content + entry, 'utf-8');
+  return { added: true };
+}
+
+module.exports = {
+  getConfigPath,
+  getReviewKeysPath,
+  cmdConfigEnsureSection,
+  cmdConfigSet,
+  cmdConfigGet,
+  writeConfigField,
+  loadReviewConfig,
+  checkConfigGitignore,
+  ensureConfigGitignored,
+};