godpowers 0.15.0

package/lib/impact.js

@@ -0,0 +1,314 @@
+/**
+ * Impact Analysis
+ *
+ * Given a change to an artifact, identify what code is affected.
+ * Uses the linkage map to propagate forward.
+ *
+ * Public API:
+ *   forArtifactDiff(projectRoot, artifactType, oldContent, newContent)
+ *     -> { changes, affectedFiles, severity }
+ *   forIdSet(projectRoot, addedIds, removedIds, changedIds)
+ *     -> { addedAffects, removedAffects, changedAffects }
+ *   transitive(projectRoot, fileSet, depth) -> Set
+ *   forDesign(projectRoot, oldContent, newContent)
+ *     -> { tokenChanges, affectedFiles, severity }
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const linkage = require('./linkage');
+const designSpec = require('./design-spec');
+const artifactDiff = require('./artifact-diff');
+
+// ============================================================================
+// ID extraction from artifact content
+// ============================================================================
+
+/**
+ * Extract stable IDs declared in artifact content.
+ * Different per artifact type.
+ */
+function extractIds(artifactType, content) {
+  const ids = new Set();
+  if (!content) return ids;
+
+  if (artifactType === 'prd') {
+    // P-MUST-NN, P-SHOULD-NN, P-COULD-NN appearing anywhere
+    const regex = /\bP-(?:MUST|SHOULD|COULD)-\d+\b/g;
+    let m;
+    while ((m = regex.exec(content)) !== null) ids.add(m[0]);
+  } else if (artifactType === 'arch') {
+    const adrRegex = /\bADR-\d+\b/g;
+    const containerRegex = /\bC-[\w-]+\b/g;
+    let m;
+    while ((m = adrRegex.exec(content)) !== null) ids.add(m[0]);
+    while ((m = containerRegex.exec(content)) !== null) ids.add(m[0]);
+  } else if (artifactType === 'roadmap') {
+    const regex = /\bM-[\w-]+\b/g;
+    let m;
+    while ((m = regex.exec(content)) !== null) ids.add(m[0]);
+  } else if (artifactType === 'stack') {
+    const regex = /\bS-[\w-]+\b/g;
+    let m;
+    while ((m = regex.exec(content)) !== null) ids.add(m[0]);
+  } else if (artifactType === 'design') {
+    const parsed = designSpec.parse(content);
+    if (parsed.frontmatter) {
+      // Token paths: walk colors / typography / spacing / rounded
+      walkTokens(parsed.frontmatter, '', ids);
+      // Component IDs: D-{slug}
+      if (parsed.frontmatter.components) {
+        for (const compName of Object.keys(parsed.frontmatter.components)) {
+          ids.add(`D-${compName}`);
+        }
+      }
+    }
+  }
+  return ids;
+}
+
+function walkTokens(obj, prefix, set) {
+  for (const [k, v] of Object.entries(obj)) {
+    if (k === 'name' || k === 'description' || k === 'components' || k === 'version') continue;
+    const here = prefix ? `${prefix}.${k}` : k;
+    if (typeof v === 'object' && v !== null && !Array.isArray(v)) {
+      walkTokens(v, here, set);
+    } else {
+      // Only token leaves (values that are colors/dimensions)
+      set.add(here);
+    }
+  }
+}
+
+// ============================================================================
+// Diff at the ID level
+// ============================================================================
+
+/**
+ * Compute added / removed / unchanged IDs from old vs new artifact content.
+ */
+function diffIds(artifactType, oldContent, newContent) {
+  const oldIds = extractIds(artifactType, oldContent);
+  const newIds = extractIds(artifactType, newContent);
+  const added = [...newIds].filter(id => !oldIds.has(id));
+  const removed = [...oldIds].filter(id => !newIds.has(id));
+  const kept = [...newIds].filter(id => oldIds.has(id));
+  return { added, removed, kept };
+}
+
+// ============================================================================
+// Impact analysis
+// ============================================================================
+
+/**
+ * Given added / removed / changed IDs, return affected files for each.
+ */
+function forIdSet(projectRoot, { added = [], removed = [], changed = [] } = {}) {
+  function lookup(ids) {
+    const result = {};
+    for (const id of ids) {
+      const files = linkage.queryByArtifact(projectRoot, id);
+      if (files.length > 0) result[id] = files;
+    }
+    return result;
+  }
+  return {
+    addedAffects: lookup(added),
+    removedAffects: lookup(removed),
+    changedAffects: lookup(changed)
+  };
+}
+
+/**
+ * High-level analysis from old/new artifact content.
+ * Severity:
+ *   error    if any ID was removed and code still references it
+ *   warning  if any ID was changed (kept but content differs)
+ *   info     if only additions
+ */
+function forArtifactDiff(projectRoot, artifactType, oldContent, newContent) {
+  const idDiff = diffIds(artifactType, oldContent, newContent);
+  const { addedAffects, removedAffects } = forIdSet(projectRoot, {
+    added: idDiff.added,
+    removed: idDiff.removed
+  });
+
+  // Also compute artifact-level diff for changed sections
+  const sectionDiff = artifactDiff.diffArtifacts(oldContent || '', newContent || '');
+
+  const affectedFiles = new Set();
+  for (const files of Object.values(addedAffects)) {
+    for (const f of files) affectedFiles.add(f);
+  }
+  for (const files of Object.values(removedAffects)) {
+    for (const f of files) affectedFiles.add(f);
+  }
+
+  let severity = 'info';
+  if (Object.keys(removedAffects).length > 0) severity = 'error';
+  else if (sectionDiff.regression) severity = 'warning';
+  else if (Object.keys(addedAffects).length > 0) severity = 'info';
+
+  return {
+    artifactType,
+    idDiff,
+    addedAffects,
+    removedAffects,
+    sectionChanges: sectionDiff.changes,
+    affectedFiles: [...affectedFiles].sort(),
+    severity
+  };
+}
+
+/**
+ * Specialized DESIGN.md impact: token + component changes.
+ */
+function forDesign(projectRoot, oldContent, newContent) {
+  const oldParsed = oldContent ? designSpec.parse(oldContent) : { frontmatter: {} };
+  const newParsed = newContent ? designSpec.parse(newContent) : { frontmatter: {} };
+
+  const tokenChanges = computeTokenChanges(
+    oldParsed.frontmatter || {},
+    newParsed.frontmatter || {}
+  );
+  const componentChanges = computeComponentChanges(
+    oldParsed.frontmatter || {},
+    newParsed.frontmatter || {}
+  );
+
+  // Affected files = files linked to any changed token or component
+  const affectedFiles = new Set();
+  for (const t of tokenChanges) {
+    const files = linkage.queryByArtifact(projectRoot, t.path);
+    for (const f of files) affectedFiles.add(f);
+  }
+  for (const c of componentChanges) {
+    const files = linkage.queryByArtifact(projectRoot, `D-${c.name}`);
+    for (const f of files) affectedFiles.add(f);
+  }
+
+  const severity = tokenChanges.some(t => t.kind === 'removed') || componentChanges.some(c => c.kind === 'removed')
+    ? 'error'
+    : (tokenChanges.length || componentChanges.length) ? 'warning' : 'info';
+
+  return {
+    tokenChanges,
+    componentChanges,
+    affectedFiles: [...affectedFiles].sort(),
+    severity
+  };
+}
+
+function computeTokenChanges(oldFm, newFm) {
+  const changes = [];
+  const oldTokens = new Map();
+  const newTokens = new Map();
+  walkTokenValues(oldFm, '', oldTokens);
+  walkTokenValues(newFm, '', newTokens);
+  for (const [path, val] of oldTokens) {
+    if (!newTokens.has(path)) {
+      changes.push({ path, kind: 'removed', oldValue: val });
+    } else if (newTokens.get(path) !== val) {
+      changes.push({ path, kind: 'modified', oldValue: val, newValue: newTokens.get(path) });
+    }
+  }
+  for (const [path, val] of newTokens) {
+    if (!oldTokens.has(path)) {
+      changes.push({ path, kind: 'added', newValue: val });
+    }
+  }
+  return changes;
+}
+
+function walkTokenValues(obj, prefix, map) {
+  for (const [k, v] of Object.entries(obj)) {
+    if (k === 'name' || k === 'description' || k === 'components' || k === 'version') continue;
+    const here = prefix ? `${prefix}.${k}` : k;
+    if (typeof v === 'object' && v !== null && !Array.isArray(v)) {
+      walkTokenValues(v, here, map);
+    } else {
+      map.set(here, String(v));
+    }
+  }
+}
+
+function computeComponentChanges(oldFm, newFm) {
+  const changes = [];
+  const oldComps = oldFm.components || {};
+  const newComps = newFm.components || {};
+  for (const name of Object.keys(oldComps)) {
+    if (!(name in newComps)) {
+      changes.push({ name, kind: 'removed' });
+    } else if (JSON.stringify(oldComps[name]) !== JSON.stringify(newComps[name])) {
+      changes.push({ name, kind: 'modified' });
+    }
+  }
+  for (const name of Object.keys(newComps)) {
+    if (!(name in oldComps)) {
+      changes.push({ name, kind: 'added' });
+    }
+  }
+  return changes;
+}
+
+// ============================================================================
+// Transitive expansion (depth-bounded)
+// ============================================================================
+
+/**
+ * Expand affected file set transitively via simple import analysis.
+ * Default depth = 2 (matches plan's recommendation).
+ */
+function transitive(projectRoot, fileSet, depth = 2) {
+  const visited = new Set();
+  let frontier = new Set(fileSet);
+  for (let d = 0; d < depth; d++) {
+    const next = new Set();
+    for (const f of frontier) {
+      if (visited.has(f)) continue;
+      visited.add(f);
+      const dependents = findDependents(projectRoot, f);
+      for (const dep of dependents) {
+        if (!visited.has(dep)) next.add(dep);
+      }
+    }
+    frontier = next;
+    if (frontier.size === 0) break;
+  }
+  return [...visited].sort();
+}
+
+function findDependents(projectRoot, targetFile) {
+  // Heuristic: scan known files for imports matching the target.
+  // For tests / fast V1: scan only files in the linkage reverse map.
+  const rev = linkage.readReverse(projectRoot);
+  const candidates = Object.keys(rev);
+  const targetBase = path.basename(targetFile, path.extname(targetFile));
+  const dependents = [];
+  for (const cand of candidates) {
+    const full = path.join(projectRoot, cand);
+    if (!fs.existsSync(full)) continue;
+    const ext = path.extname(cand);
+    if (!['.js', '.jsx', '.ts', '.tsx', '.mjs', '.css', '.scss'].includes(ext)) continue;
+    let content;
+    try {
+      content = fs.readFileSync(full, 'utf8');
+    } catch (e) {
+      continue;
+    }
+    if (content.includes(targetBase) && cand !== targetFile) {
+      dependents.push(cand);
+    }
+  }
+  return dependents;
+}
+
+module.exports = {
+  extractIds,
+  diffIds,
+  forIdSet,
+  forArtifactDiff,
+  forDesign,
+  transitive
+};

package/lib/impeccable-bridge.js

@@ -0,0 +1,139 @@
+/**
+ * Impeccable Bridge
+ *
+ * Thin invocation layer between godpowers and the impeccable design skill.
+ * Detects impeccable presence; dispatches commands; captures findings.
+ *
+ * IMPORTANT: Impeccable is never vendored. This module only detects and
+ * delegates. If impeccable is not installed, command dispatch returns a
+ * graceful "not-installed" result that callers can act on.
+ *
+ * Public API:
+ *   isInstalled(projectRoot) -> bool
+ *   getInstallation(projectRoot) -> { installed, locations, primaryTool }
+ *   runDetect(targetPath, opts) -> { findings, error }   // shells out to npx impeccable
+ *   describeBridge() -> { commands, sourcedFrom }        // metadata
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const designDetector = require('./design-detector');
+
+const IMPECCABLE_COMMANDS = [
+  'craft', 'teach', 'document', 'extract', 'shape',
+  'critique', 'audit', 'polish',
+  'bolder', 'quieter', 'distill', 'harden', 'onboard',
+  'animate', 'colorize', 'typeset', 'layout',
+  'delight', 'overdrive', 'clarify', 'adapt', 'optimize', 'live'
+];
+
+/**
+ * Quick presence check. Delegates to design-detector for consistency.
+ */
+function isInstalled(projectRoot) {
+  return designDetector.isImpeccableInstalled(projectRoot).installed;
+}
+
+/**
+ * Detailed installation info: where impeccable is found.
+ * Identifies the primary AI tool from the first matched skill location.
+ */
+function getInstallation(projectRoot) {
+  const result = designDetector.isImpeccableInstalled(projectRoot);
+  let primaryTool = null;
+  for (const loc of result.locations) {
+    if (loc.includes('.claude')) { primaryTool = 'claude-code'; break; }
+    if (loc.includes('.cursor')) { primaryTool = 'cursor'; break; }
+    if (loc.includes('.gemini')) { primaryTool = 'gemini'; break; }
+    if (loc.includes('.opencode')) { primaryTool = 'opencode'; break; }
+    if (loc.includes('.kiro')) { primaryTool = 'kiro'; break; }
+    if (loc.includes('.qoder')) { primaryTool = 'qoder'; break; }
+    if (loc.includes('.rovodev')) { primaryTool = 'rovodev'; break; }
+    if (loc.includes('.trae')) { primaryTool = 'trae'; break; }
+    if (loc.includes('.agents')) { primaryTool = 'codex'; break; }
+    if (loc.includes('.github')) { primaryTool = 'copilot'; break; }
+    if (loc.includes('node_modules')) { primaryTool = 'npm'; break; }
+  }
+  return {
+    installed: result.installed,
+    locations: result.locations,
+    primaryTool
+  };
+}
+
+/**
+ * Run `npx impeccable detect <target>` and parse the JSON output.
+ * Returns { findings, error }.
+ *
+ * If impeccable CLI is not available, returns
+ *   { findings: [], error: 'not-installed' }
+ *
+ * Callers should pass `--fast --json` or rely on this function's defaults.
+ */
+function runDetect(targetPath, opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  if (!isInstalled(cwd) && !opts.forceRun) {
+    return { findings: [], error: 'not-installed' };
+  }
+  const args = ['impeccable', 'detect', '--fast', '--json'];
+  if (targetPath) args.push(targetPath);
+  try {
+    // Use execFileSync with array args (no shell, no injection risk).
+    const { execFileSync } = require('child_process');
+    const output = execFileSync('npx', args, {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 30_000
+    });
+    let parsed;
+    try {
+      parsed = JSON.parse(output);
+    } catch (e) {
+      return { findings: [], error: 'parse-error', raw: output };
+    }
+    return {
+      findings: parsed.findings || [],
+      summary: parsed.summary || null,
+      error: null
+    };
+  } catch (e) {
+    return { findings: [], error: 'execution-error', message: e.message };
+  }
+}
+
+/**
+ * Metadata about the bridge: which commands are bridged, where they delegate.
+ */
+function describeBridge() {
+  return {
+    commands: IMPECCABLE_COMMANDS,
+    sourcedFrom: 'https://github.com/pbakaus/impeccable',
+    integrationModel: 'detect-and-delegate; never vendored',
+    bridgeFunctions: ['isInstalled', 'getInstallation', 'runDetect']
+  };
+}
+
+/**
+ * Build a god-design subcommand -> impeccable command mapping.
+ */
+function commandMap() {
+  const map = {};
+  for (const cmd of IMPECCABLE_COMMANDS) {
+    map[`/god-design ${cmd}`] = `/impeccable ${cmd}`;
+  }
+  // Aliases for godpowers-natural names
+  map['/god-design refresh'] = '/impeccable document';
+  return map;
+}
+
+module.exports = {
+  isInstalled,
+  getInstallation,
+  runDetect,
+  describeBridge,
+  commandMap,
+  IMPECCABLE_COMMANDS
+};

package/lib/intent.js

@@ -0,0 +1,177 @@
+/**
+ * Intent Manager
+ *
+ * Read .godpowers/intent.yaml. Validate basic structure.
+ *
+ * Note: this is a minimal YAML reader, intentionally avoiding a YAML
+ * dependency. Handles the subset of YAML our intent files use.
+ * For complex YAML, agents read the file directly.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function intentPath(projectRoot) {
+  return path.join(projectRoot, '.godpowers', 'intent.yaml');
+}
+
+/**
+ * Read intent.yaml. Returns parsed object or null if not found.
+ *
+ * Minimal YAML parser: handles the subset our schema uses
+ * (key: value, nested objects, arrays of strings, booleans).
+ * For full YAML, agents should use a real parser.
+ */
+function read(projectRoot) {
+  const file = intentPath(projectRoot);
+  if (!fs.existsSync(file)) return null;
+  const content = fs.readFileSync(file, 'utf8');
+  return parseSimpleYaml(content);
+}
+
+/**
+ * Parse a simple YAML subset. Just enough for intent.yaml structure.
+ * Real-world: replace with `yaml` npm package when we add deps.
+ */
+function parseSimpleYaml(content) {
+  const lines = content.split('\n');
+  const result = {};
+  const stack = [{ obj: result, indent: -1, key: null, isArray: false, parent: null }];
+
+  for (let line of lines) {
+    if (!line.trim() || line.trim().startsWith('#')) continue;
+    // Strip inline comments (but not # inside quotes)
+    const hashIdx = line.indexOf(' #');
+    if (hashIdx !== -1) {
+      // Make sure the # isn't inside a quoted string
+      const before = line.slice(0, hashIdx);
+      const dquoteCount = (before.match(/"/g) || []).length;
+      const squoteCount = (before.match(/'/g) || []).length;
+      if (dquoteCount % 2 === 0 && squoteCount % 2 === 0) {
+        line = before;
+      }
+    }
+
+    const indent = line.length - line.trimStart().length;
+    const trimmed = line.trim();
+
+    // Pop stack to the right indent level
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+      stack.pop();
+    }
+    const parent = stack[stack.length - 1].obj;
+    const parentMeta = stack[stack.length - 1];
+
+    // List item: "- key: value" or "- value"
+    if (trimmed.startsWith('- ')) {
+      const rest = trimmed.slice(2);
+      // If the rest is a quoted string, treat as simple value (don't split on colon)
+      const isQuotedSimple = /^"[^"]*"$|^'[^']*'$/.test(rest.trim());
+      const restColonIdx = isQuotedSimple ? -1 : rest.indexOf(':');
+
+      // Ensure parent is array
+      if (!Array.isArray(parent.__items__)) {
+        parent.__items__ = [];
+      }
+
+      if (restColonIdx === -1) {
+        // Simple list value: "- value"
+        parent.__items__.push(parseValue(rest.trim()));
+      } else {
+        // List of objects: "- key: value"
+        const itemKey = rest.slice(0, restColonIdx).trim();
+        const itemVal = rest.slice(restColonIdx + 1).trim();
+        const newObj = {};
+        if (itemVal) {
+          newObj[itemKey] = parseValue(itemVal);
+        } else {
+          newObj[itemKey] = {};
+          // Inner object's properties start at indent+4 (2 for "- " + 2 for key indentation)
+          stack.push({ obj: newObj[itemKey], indent: indent + 3, key: itemKey, parent: newObj });
+        }
+        parent.__items__.push(newObj);
+        // Push the new object onto the stack at indent+1 so subsequent properties
+        // at indent+2 (the "- " offset) go into it. The +1 ensures it's NOT popped
+        // when we encounter properties at the same visual indent as the "-".
+        stack.push({ obj: newObj, indent: indent + 1, key: '__item__', parent });
+      }
+      continue;
+    }
+
+    const colonIdx = trimmed.indexOf(':');
+    if (colonIdx === -1) continue;
+    const key = trimmed.slice(0, colonIdx).trim();
+    const valueStr = trimmed.slice(colonIdx + 1).trim();
+
+    if (!valueStr) {
+      const child = {};
+      parent[key] = child;
+      stack.push({ obj: child, indent, key, parent });
+    } else if (valueStr === '|' || valueStr === '>') {
+      parent[key] = '';
+    } else {
+      parent[key] = parseValue(valueStr);
+    }
+  }
+
+  return cleanArrays(result);
+}
+
+function parseValue(str) {
+  if (str === 'true') return true;
+  if (str === 'false') return false;
+  if (str === 'null' || str === '~') return null;
+  if (/^-?\d+$/.test(str)) return parseInt(str, 10);
+  if (/^-?\d+\.\d+$/.test(str)) return parseFloat(str);
+  if (/^".*"$/.test(str) || /^'.*'$/.test(str)) return str.slice(1, -1);
+  // Inline array: [/god-mode, /god-foo]
+  if (/^\[.*\]$/.test(str)) {
+    const inner = str.slice(1, -1).trim();
+    if (!inner) return [];
+    return inner.split(',').map(s => parseValue(s.trim()));
+  }
+  return str;
+}
+
+function cleanArrays(obj) {
+  if (Array.isArray(obj)) return obj.map(cleanArrays);
+  if (obj && typeof obj === 'object') {
+    // Detect array container (legacy or new)
+    if (obj.__items__) return obj.__items__.map(cleanArrays);
+    if (obj.__pending_array__) return obj.__pending_array__;
+    const cleaned = {};
+    for (const [k, v] of Object.entries(obj)) {
+      cleaned[k] = cleanArrays(v);
+    }
+    return cleaned;
+  }
+  return obj;
+}
+
+/**
+ * Get a setting from intent.yaml using dot notation.
+ * Example: get(root, 'config.yolo')
+ */
+function get(intent, key) {
+  if (!intent) return undefined;
+  return key.split('.').reduce((acc, k) => (acc && acc[k] !== undefined ? acc[k] : undefined), intent);
+}
+
+/**
+ * Validate the structure of an intent object against expected shape.
+ * Returns array of error messages (empty if valid).
+ */
+function validate(intent) {
+  const errors = [];
+  if (!intent) return ['intent is null'];
+  if (intent.apiVersion !== 'godpowers/v1') errors.push('apiVersion must be godpowers/v1');
+  if (intent.kind !== 'Project') errors.push('kind must be Project');
+  if (!intent.metadata || !intent.metadata.name) errors.push('metadata.name required');
+  if (!['A', 'B', 'C', 'E'].includes(intent.mode)) errors.push('mode must be A, B, C, or E (D is a suite-membership boolean, mode-d-suite, not a primary mode)');
+  if (!['trivial', 'small', 'medium', 'large', 'enterprise'].includes(intent.scale)) {
+    errors.push('scale must be trivial/small/medium/large/enterprise');
+  }
+  return errors;
+}
+
+module.exports = { read, get, validate, intentPath, parseSimpleYaml };