ripp-cli 1.0.0

package/lib/build.js

@@ -0,0 +1,338 @@
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+/**
+ * RIPP Build - Canonical Artifact Compilation
+ * Deterministic compilation of confirmed intent into canonical RIPP artifacts
+ */
+
+/**
+ * Build canonical RIPP artifacts from confirmed intent
+ */
+function buildCanonicalArtifacts(cwd, options = {}) {
+  const confirmedPath = path.join(cwd, '.ripp', 'intent.confirmed.yaml');
+
+  if (!fs.existsSync(confirmedPath)) {
+    throw new Error('No confirmed intent found. Run "ripp confirm" first.');
+  }
+
+  const confirmedContent = fs.readFileSync(confirmedPath, 'utf8');
+  const confirmed = yaml.load(confirmedContent);
+
+  if (!confirmed.confirmed || confirmed.confirmed.length === 0) {
+    throw new Error('No confirmed intent blocks found');
+  }
+
+  // Build RIPP packet from confirmed intent
+  const packet = buildRippPacket(confirmed, options);
+
+  // Validate the packet
+  const validation = validatePacket(packet);
+  if (!validation.valid) {
+    throw new Error(`Generated packet failed validation: ${validation.errors.join(', ')}`);
+  }
+
+  // Write canonical packet
+  const packetPath = path.join(cwd, '.ripp', options.outputName || 'handoff.ripp.yaml');
+  fs.writeFileSync(packetPath, yaml.dump(packet, { indent: 2, lineWidth: 100 }), 'utf8');
+
+  // Generate handoff.ripp.md (consolidated markdown)
+  const markdown = generateHandoffMarkdown(packet, confirmed);
+  const markdownPath = path.join(cwd, '.ripp', 'handoff.ripp.md');
+  fs.writeFileSync(markdownPath, markdown, 'utf8');
+
+  return {
+    packetPath,
+    markdownPath,
+    packet,
+    level: packet.level
+  };
+}
+
+/**
+ * Build RIPP packet from confirmed intent blocks
+ */
+function buildRippPacket(confirmed, options) {
+  const now = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
+
+  // Initialize packet with required metadata
+  const packet = {
+    ripp_version: '1.0',
+    packet_id: options.packetId || 'discovered-intent',
+    title: options.title || 'Discovered Intent',
+    created: now,
+    updated: now,
+    status: 'draft',
+    level: determineLevel(confirmed.confirmed),
+    purpose: null,
+    ux_flow: null,
+    data_contracts: null
+  };
+
+  // Add metadata about generation
+  packet.metadata = {
+    generated_from: 'ripp-discovery',
+    generated_at: new Date().toISOString(),
+    source: 'confirmed-intent',
+    total_confirmed_blocks: confirmed.confirmed.length
+  };
+
+  // Populate sections from confirmed intent
+  confirmed.confirmed.forEach(block => {
+    const section = block.section;
+    const content = block.content;
+
+    switch (section) {
+      case 'purpose':
+        packet.purpose = content;
+        break;
+      case 'ux_flow':
+        packet.ux_flow = Array.isArray(content) ? content : [content];
+        break;
+      case 'data_contracts':
+        packet.data_contracts = content;
+        break;
+      case 'api_contracts':
+        packet.api_contracts = Array.isArray(content) ? content : [content];
+        break;
+      case 'permissions':
+        packet.permissions = Array.isArray(content) ? content : [content];
+        break;
+      case 'failure_modes':
+        packet.failure_modes = Array.isArray(content) ? content : [content];
+        break;
+      case 'audit_events':
+        packet.audit_events = Array.isArray(content) ? content : [content];
+        break;
+      case 'nfrs':
+        packet.nfrs = content;
+        break;
+      case 'acceptance_tests':
+        packet.acceptance_tests = Array.isArray(content) ? content : [content];
+        break;
+    }
+  });
+
+  // Ensure required sections exist (add placeholders if missing)
+  if (!packet.purpose) {
+    packet.purpose = {
+      problem: 'TODO: Define the problem being solved',
+      solution: 'TODO: Describe the solution approach',
+      value: 'TODO: Specify the value delivered'
+    };
+  }
+
+  if (!packet.ux_flow || packet.ux_flow.length === 0) {
+    packet.ux_flow = [
+      {
+        step: 1,
+        actor: 'User',
+        action: 'TODO: Define user interaction',
+        trigger: 'TODO: Define trigger'
+      }
+    ];
+  }
+
+  if (!packet.data_contracts) {
+    packet.data_contracts = {
+      inputs: [],
+      outputs: []
+    };
+  }
+
+  return packet;
+}
+
+/**
+ * Determine RIPP level based on confirmed sections
+ */
+function determineLevel(confirmed) {
+  const sections = new Set(confirmed.map(b => b.section));
+
+  // Level 3 requirements
+  if (sections.has('audit_events') || sections.has('nfrs') || sections.has('acceptance_tests')) {
+    return 3;
+  }
+
+  // Level 2 requirements
+  if (
+    sections.has('api_contracts') ||
+    sections.has('permissions') ||
+    sections.has('failure_modes')
+  ) {
+    return 2;
+  }
+
+  // Default to Level 1
+  return 1;
+}
+
+/**
+ * Basic validation of generated packet
+ */
+function validatePacket(packet) {
+  const errors = [];
+
+  // Required fields
+  if (!packet.ripp_version) errors.push('Missing ripp_version');
+  if (!packet.packet_id) errors.push('Missing packet_id');
+  if (!packet.title) errors.push('Missing title');
+  if (!packet.created) errors.push('Missing created');
+  if (!packet.updated) errors.push('Missing updated');
+  if (!packet.status) errors.push('Missing status');
+  if (!packet.level) errors.push('Missing level');
+
+  // Required sections
+  if (!packet.purpose) errors.push('Missing purpose section');
+  if (!packet.ux_flow) errors.push('Missing ux_flow section');
+  if (!packet.data_contracts) errors.push('Missing data_contracts section');
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Generate handoff.ripp.md (consolidated markdown output)
+ */
+function generateHandoffMarkdown(packet, confirmed) {
+  let md = `# ${packet.title}\n\n`;
+  md += `**RIPP Packet** — Generated from Intent Discovery Mode\n\n`;
+  md += `- **Packet ID**: ${packet.packet_id}\n`;
+  md += `- **Level**: ${packet.level}\n`;
+  md += `- **Status**: ${packet.status}\n`;
+  md += `- **Generated**: ${packet.metadata.generated_at}\n\n`;
+
+  md += `---\n\n`;
+
+  // Purpose
+  md += `## Purpose\n\n`;
+  if (packet.purpose) {
+    md += `**Problem**: ${packet.purpose.problem}\n\n`;
+    md += `**Solution**: ${packet.purpose.solution}\n\n`;
+    md += `**Value**: ${packet.purpose.value}\n\n`;
+  }
+
+  // UX Flow
+  md += `## UX Flow\n\n`;
+  if (packet.ux_flow) {
+    packet.ux_flow.forEach(step => {
+      md += `### Step ${step.step}\n\n`;
+      md += `- **Actor**: ${step.actor}\n`;
+      md += `- **Action**: ${step.action}\n`;
+      if (step.trigger) md += `- **Trigger**: ${step.trigger}\n`;
+      if (step.result) md += `- **Result**: ${step.result}\n`;
+      md += `\n`;
+    });
+  }
+
+  // Data Contracts
+  md += `## Data Contracts\n\n`;
+  if (packet.data_contracts) {
+    md += `### Inputs\n\n`;
+    if (packet.data_contracts.inputs && packet.data_contracts.inputs.length > 0) {
+      packet.data_contracts.inputs.forEach(input => {
+        md += `#### ${input.name}\n\n`;
+        if (input.fields) {
+          input.fields.forEach(field => {
+            md += `- **${field.name}** (${field.type})${field.required ? ' *required*' : ''}: ${field.description || 'N/A'}\n`;
+          });
+        }
+        md += `\n`;
+      });
+    } else {
+      md += `*None defined*\n\n`;
+    }
+
+    md += `### Outputs\n\n`;
+    if (packet.data_contracts.outputs && packet.data_contracts.outputs.length > 0) {
+      packet.data_contracts.outputs.forEach(output => {
+        md += `#### ${output.name}\n\n`;
+        if (output.fields) {
+          output.fields.forEach(field => {
+            md += `- **${field.name}** (${field.type})${field.required ? ' *required*' : ''}: ${field.description || 'N/A'}\n`;
+          });
+        }
+        md += `\n`;
+      });
+    } else {
+      md += `*None defined*\n\n`;
+    }
+  }
+
+  // Level 2+ sections
+  if (packet.level >= 2) {
+    if (packet.api_contracts) {
+      md += `## API Contracts\n\n`;
+      packet.api_contracts.forEach(api => {
+        md += `### ${api.method} ${api.endpoint}\n\n`;
+        md += `**Purpose**: ${api.purpose || 'N/A'}\n\n`;
+      });
+    }
+
+    if (packet.permissions) {
+      md += `## Permissions\n\n`;
+      packet.permissions.forEach(perm => {
+        md += `- **${perm.action}**: ${perm.description || 'N/A'}\n`;
+      });
+      md += `\n`;
+    }
+
+    if (packet.failure_modes) {
+      md += `## Failure Modes\n\n`;
+      packet.failure_modes.forEach(fm => {
+        md += `- **${fm.scenario}**: ${fm.handling || 'N/A'}\n`;
+      });
+      md += `\n`;
+    }
+  }
+
+  // Level 3 sections
+  if (packet.level >= 3) {
+    if (packet.audit_events) {
+      md += `## Audit Events\n\n`;
+      packet.audit_events.forEach(event => {
+        md += `- **${event.event}** (${event.severity}): ${event.purpose || 'N/A'}\n`;
+      });
+      md += `\n`;
+    }
+
+    if (packet.nfrs) {
+      md += `## Non-Functional Requirements\n\n`;
+      md += `\`\`\`yaml\n${yaml.dump(packet.nfrs, { indent: 2 })}\`\`\`\n\n`;
+    }
+
+    if (packet.acceptance_tests) {
+      md += `## Acceptance Tests\n\n`;
+      packet.acceptance_tests.forEach(test => {
+        md += `### ${test.title}\n\n`;
+        md += `- **Given**: ${test.given}\n`;
+        md += `- **When**: ${test.when}\n`;
+        md += `- **Then**: ${test.then}\n\n`;
+      });
+    }
+  }
+
+  // Provenance
+  md += `---\n\n`;
+  md += `## Provenance\n\n`;
+  md += `This RIPP packet was generated using Intent Discovery Mode.\n\n`;
+  md += `- **Total Confirmed Blocks**: ${confirmed.confirmed.length}\n`;
+  md += `- **Generation Method**: AI-assisted with human confirmation\n`;
+  md += `- **Validation**: Passed schema validation at generation time\n\n`;
+
+  md += `### Confirmed Blocks\n\n`;
+  confirmed.confirmed.forEach((block, index) => {
+    md += `${index + 1}. **${block.section}** (confidence: ${(block.original_confidence * 100).toFixed(1)}%) - confirmed at ${block.confirmed_at}\n`;
+  });
+
+  return md;
+}
+
+module.exports = {
+  buildCanonicalArtifacts,
+  buildRippPacket,
+  generateHandoffMarkdown
+};

package/lib/config.js

@@ -0,0 +1,277 @@
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+const Ajv = require('ajv');
+const addFormats = require('ajv-formats');
+
+/**
+ * RIPP Configuration Manager
+ * Handles loading and validation of .ripp/config.yaml with precedence rules
+ */
+
+const DEFAULT_CONFIG = {
+  rippVersion: '1.0',
+  ai: {
+    enabled: false,
+    provider: 'openai',
+    model: 'gpt-4o-mini',
+    maxRetries: 3,
+    timeout: 30000
+  },
+  evidencePack: {
+    includeGlobs: ['src/**', 'app/**', 'api/**', 'db/**', '.github/workflows/**'],
+    excludeGlobs: [
+      '**/node_modules/**',
+      '**/dist/**',
+      '**/build/**',
+      '**/*.lock',
+      '**/.git/**',
+      '**/vendor/**',
+      '**/.ripp/**'
+    ],
+    maxFileSize: 1048576, // 1MB
+    secretPatterns: []
+  },
+  discovery: {
+    minConfidence: 0.5,
+    includeEvidence: true
+  }
+};
+
+/**
+ * Load RIPP configuration from .ripp/config.yaml
+ * Applies precedence: defaults < repo config < env vars
+ */
+function loadConfig(cwd = process.cwd()) {
+  const configPath = path.join(cwd, '.ripp', 'config.yaml');
+
+  // Start with defaults
+  let config = JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+
+  // Load repo config if exists
+  if (fs.existsSync(configPath)) {
+    try {
+      const fileContent = fs.readFileSync(configPath, 'utf8');
+      const repoConfig = yaml.load(fileContent);
+
+      // Merge with defaults
+      config = mergeConfig(config, repoConfig);
+
+      // Validate against schema
+      // Resolve schema path from project root (3 levels up from lib/)
+      const projectRoot = path.join(__dirname, '../../..');
+      const schemaPath = path.join(projectRoot, 'schema/ripp-config.schema.json');
+
+      if (!fs.existsSync(schemaPath)) {
+        throw new Error(`Schema file not found at: ${schemaPath}`);
+      }
+
+      const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
+
+      const ajv = new Ajv({ allErrors: true, strict: false });
+      addFormats(ajv);
+      const validate = ajv.compile(schema);
+      const valid = validate(config);
+
+      if (!valid) {
+        const errors = validate.errors.map(e => `${e.instancePath}: ${e.message}`).join(', ');
+        throw new Error(`Invalid .ripp/config.yaml: ${errors}`);
+      }
+    } catch (error) {
+      if (error.message.includes('Invalid .ripp/config.yaml')) {
+        throw error;
+      }
+      throw new Error(`Failed to parse .ripp/config.yaml: ${error.message}`);
+    }
+  }
+
+  // Apply environment variable overrides
+  config = applyEnvOverrides(config);
+
+  return config;
+}
+
+/**
+ * Merge configuration objects (deep merge for nested objects)
+ */
+function mergeConfig(base, override) {
+  const result = { ...base };
+
+  for (const key in override) {
+    if (override[key] !== undefined && override[key] !== null) {
+      if (
+        typeof override[key] === 'object' &&
+        !Array.isArray(override[key]) &&
+        typeof base[key] === 'object' &&
+        !Array.isArray(base[key])
+      ) {
+        result[key] = mergeConfig(base[key] || {}, override[key]);
+      } else {
+        result[key] = override[key];
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Apply environment variable overrides
+ * Env vars take precedence ONLY if ai.enabled=true in repo config
+ */
+function applyEnvOverrides(config) {
+  const result = { ...config };
+
+  // AI configuration (only if enabled in repo)
+  if (result.ai.enabled) {
+    // RIPP_AI_ENABLED must also be true
+    const aiEnabledEnv = process.env.RIPP_AI_ENABLED;
+    if (aiEnabledEnv !== undefined) {
+      const enabled = aiEnabledEnv.toLowerCase() === 'true';
+      if (!enabled) {
+        // Env var explicitly disables AI
+        result.ai.enabled = false;
+      }
+    }
+
+    // Other AI settings (only if AI is enabled)
+    if (result.ai.enabled) {
+      if (process.env.RIPP_AI_PROVIDER) {
+        result.ai.provider = process.env.RIPP_AI_PROVIDER;
+      }
+      if (process.env.RIPP_AI_MODEL) {
+        result.ai.model = process.env.RIPP_AI_MODEL;
+      }
+      if (process.env.RIPP_AI_ENDPOINT) {
+        result.ai.customEndpoint = process.env.RIPP_AI_ENDPOINT;
+      }
+      if (process.env.RIPP_AI_MAX_RETRIES) {
+        result.ai.maxRetries = parseInt(process.env.RIPP_AI_MAX_RETRIES, 10);
+      }
+      if (process.env.RIPP_AI_TIMEOUT) {
+        result.ai.timeout = parseInt(process.env.RIPP_AI_TIMEOUT, 10);
+      }
+    }
+  } else {
+    // If ai.enabled=false in repo config, AI is ALWAYS OFF
+    result.ai.enabled = false;
+  }
+
+  return result;
+}
+
+/**
+ * Check if AI is enabled and properly configured
+ * Returns { enabled: boolean, reason: string }
+ */
+function checkAiEnabled(config) {
+  if (!config.ai.enabled) {
+    return {
+      enabled: false,
+      reason: 'AI is disabled in .ripp/config.yaml (ai.enabled: false)'
+    };
+  }
+
+  // Check for runtime env var
+  const aiEnabledEnv = process.env.RIPP_AI_ENABLED;
+  if (aiEnabledEnv === undefined || aiEnabledEnv.toLowerCase() !== 'true') {
+    return {
+      enabled: false,
+      reason: 'AI is enabled in config but RIPP_AI_ENABLED env var is not set to "true"'
+    };
+  }
+
+  // Check for API key based on provider
+  const provider = config.ai.provider;
+  if (provider === 'openai') {
+    if (!process.env.OPENAI_API_KEY) {
+      return {
+        enabled: false,
+        reason: 'OPENAI_API_KEY environment variable is not set'
+      };
+    }
+  } else if (provider === 'azure-openai') {
+    if (!process.env.AZURE_OPENAI_API_KEY || !process.env.AZURE_OPENAI_ENDPOINT) {
+      return {
+        enabled: false,
+        reason: 'AZURE_OPENAI_API_KEY and AZURE_OPENAI_ENDPOINT environment variables are required'
+      };
+    }
+  } else if (provider === 'custom') {
+    if (!config.ai.customEndpoint) {
+      return {
+        enabled: false,
+        reason: 'Custom provider requires customEndpoint in config'
+      };
+    }
+  }
+
+  return { enabled: true, reason: '' };
+}
+
+/**
+ * Create default .ripp/config.yaml file
+ */
+function createDefaultConfig(cwd = process.cwd(), options = {}) {
+  const rippDir = path.join(cwd, '.ripp');
+  const configPath = path.join(rippDir, 'config.yaml');
+
+  // Create .ripp directory if it doesn't exist
+  if (!fs.existsSync(rippDir)) {
+    fs.mkdirSync(rippDir, { recursive: true });
+  }
+
+  // Check if config already exists
+  if (fs.existsSync(configPath) && !options.force) {
+    return { created: false, path: configPath };
+  }
+
+  // Create config with helpful comments
+  const configContent = `# RIPP Configuration
+# Version: 1.0
+# Documentation: https://dylan-natter.github.io/ripp-protocol
+
+rippVersion: "1.0"
+
+# AI Configuration (vNext Intent Discovery Mode)
+# AI is DISABLED BY DEFAULT for security and trust
+ai:
+  enabled: false  # Set to true AND set RIPP_AI_ENABLED=true to enable AI features
+  provider: openai  # openai | azure-openai | ollama | custom
+  model: gpt-4o-mini  # Model identifier
+
+# Evidence Pack Configuration
+evidencePack:
+  includeGlobs:
+    - "src/**"
+    - "app/**"
+    - "api/**"
+    - "db/**"
+    - ".github/workflows/**"
+  excludeGlobs:
+    - "**/node_modules/**"
+    - "**/dist/**"
+    - "**/build/**"
+    - "**/*.lock"
+    - "**/.git/**"
+    - "**/vendor/**"
+    - "**/.ripp/**"
+  maxFileSize: 1048576  # 1MB
+
+# Discovery Configuration
+discovery:
+  minConfidence: 0.5  # Minimum confidence for AI-inferred intent (0.0-1.0)
+  includeEvidence: true  # Include evidence references in candidates
+`;
+
+  fs.writeFileSync(configPath, configContent, 'utf8');
+
+  return { created: true, path: configPath };
+}
+
+module.exports = {
+  loadConfig,
+  checkAiEnabled,
+  createDefaultConfig,
+  DEFAULT_CONFIG
+};