gemstack-ai 1.2.0 → 1.3.0

package/src/cli.js

@@ -11,6 +11,7 @@ const installCommand = require('./commands/install');
 const verifyCommand = require('./commands/verify');
 const collectCommand = require('./commands/collect');
 const shipCommand = require('./commands/ship');
+const contextCommand = require('./commands/context');
 
 async function main() {
     const { command, args, flags } = parser.parse(process.argv);
@@ -48,6 +49,7 @@ Options:
             case 'audit': await verifyCommand(flags); break;
             case 'collect': await collectCommand(flags); break;
             case 'ship': await shipCommand(flags); break;
+            case 'context': await contextCommand(args, flags); break;
             case 'list': await listCommand(flags); break;
             case 'show': await showCommand(args[0], flags); break;
             case 'hooks': hooksCommand.installHooks(flags.target); break;

package/src/commands/context.js

@@ -0,0 +1,95 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const logger = require('../lib/logger');
+const fssafe = require('../lib/filesystem-safe');
+const {
+  generateContextCapsule,
+  validateContextCapsule
+} = require('../lib/context-capsule');
+
+async function contextCommand(args = [], flags = {}) {
+  const subcommand = args[0] || 'show';
+  const targetDir = flags.target ? path.resolve(flags.target) : process.cwd();
+
+  let activeSpec = flags.feature;
+  if (!activeSpec) {
+    const stateFile = path.join(targetDir, '.gemstack/state.json');
+    if (fs.existsSync(stateFile)) {
+      try {
+        const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+        activeSpec = state.active_spec;
+      } catch (_) {}
+    }
+  }
+
+  if (!activeSpec) {
+    // Check if specs/009-context-capsule or specs/current exists
+    if (fs.existsSync(path.join(targetDir, 'specs/009-context-capsule'))) {
+      activeSpec = 'specs/009-context-capsule';
+    } else if (fs.existsSync(path.join(targetDir, 'specs/current'))) {
+      activeSpec = 'specs/current';
+    } else {
+      logger.error('No active feature found or specified via --feature.');
+      process.exit(1);
+    }
+  }
+
+  switch (subcommand) {
+    case 'generate': {
+      logger.info(`Generating context capsule for "${activeSpec}" in: ${targetDir}`);
+      try {
+        const res = generateContextCapsule(targetDir, activeSpec);
+        logger.ok(`Context capsule generated successfully: ${res.path} (${res.byteLength} bytes, ${res.invariantsCount} invariants).`);
+      } catch (err) {
+        logger.error(`Generation failed: ${err.message}`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    case 'show': {
+      const capsuleFile = path.join(targetDir, activeSpec, 'context-capsule.json');
+      if (!fs.existsSync(capsuleFile)) {
+        logger.error(`Context capsule not found at: ${capsuleFile}`);
+        process.exit(1);
+      }
+      const raw = fs.readFileSync(capsuleFile, 'utf8');
+      if (flags.json) {
+        console.log(raw);
+      } else {
+        const parsed = JSON.parse(raw);
+        console.log('=== Gemstack Context Capsule ===');
+        console.log(`Schema Version: ${parsed.schema_version}`);
+        console.log(`Project:        ${parsed.project ? parsed.project.name : 'unknown'}`);
+        console.log(`Feature:        ${parsed.project ? parsed.project.active_feature : 'unknown'}`);
+        console.log(`Lifecycle:      ${parsed.project ? parsed.project.lifecycle_status : 'unknown'}`);
+        console.log(`Sources:        ${parsed.provenance ? parsed.provenance.sources.length : 0} files`);
+        console.log(`Invariants:     ${parsed.canonical_invariants ? parsed.canonical_invariants.length : 0} rules`);
+        console.log(`Contracts:      ${parsed.frozen_contracts ? parsed.frozen_contracts.length : 0} contracts`);
+        console.log(`Acceptance:     ${parsed.acceptance_matrix ? parsed.acceptance_matrix.total_required : 0} tests`);
+      }
+      break;
+    }
+
+    case 'verify': {
+      logger.info(`Auditing context capsule for "${activeSpec}" in: ${targetDir}`);
+      const res = validateContextCapsule(targetDir, activeSpec);
+      if (res.valid) {
+        logger.ok(`[OK] Context capsule is VALID and FRESH for ${activeSpec}.`);
+      } else {
+        logger.error(`[${res.state}] Context capsule validation failed.`);
+        for (const f of res.findings) {
+          logger.error(` - [${f.code}] ${f.message}`);
+        }
+        process.exit(1);
+      }
+      break;
+    }
+
+    default:
+      logger.error(`Unknown context subcommand: ${subcommand}. Valid subcommands: generate, show, verify.`);
+      process.exit(1);
+  }
+}
+
+module.exports = contextCommand;

package/src/commands/verify.js

@@ -376,6 +376,60 @@ module.exports = async (flags) => {
         logger.ok('Sin spec activa configurada para validación de evidencia de cierre.');
     }
 
+    // 5.1 Verificación de Políticas de Costos y Proveedores (Upgrade C - Read-Only)
+    const { loadCostLedger } = require('../lib/cost-ledger');
+    let costLedgerFound = false;
+    const ledgerCandidates = [];
+    if (loadedState && loadedState.active_spec) {
+        ledgerCandidates.push(fssafe.resolveSafe(targetDir, path.join(loadedState.active_spec, 'cost-ledger.json')));
+    }
+    ledgerCandidates.push(fssafe.resolveSafe(targetDir, 'cost-ledger.json'));
+    ledgerCandidates.push(fssafe.resolveSafe(targetDir, '.gemstack/cost-ledger.json'));
+
+    for (const lPath of ledgerCandidates) {
+        if (fs.existsSync(lPath)) {
+            costLedgerFound = true;
+            const res = loadCostLedger(lPath);
+            if (res.findings.length > 0) {
+                for (const f of res.findings) {
+                    if (f.is_blocking) {
+                        logger.error(`[COST_SAFETY_BLOCKER] ${f.code}: ${f.details}`);
+                        totalErrors++;
+                    } else {
+                        logger.warn(`[COST_SAFETY_WARNING] ${f.code}: ${f.details}`);
+                        totalWarnings++;
+                    }
+                }
+            } else {
+                logger.ok(`Cost ledger verificado (${path.basename(lPath)}): íntegro y sin secretos.`);
+            }
+            break;
+        }
+    }
+
+    if (!costLedgerFound) {
+        logger.info('[LEGACY] [LEGACY_NO_PROVIDERS_DECLARED] No se detectaron declaraciones de costos o proveedores (Modo Legacy Provider-Free).');
+    }
+
+    // 5.2 Verificación de Context Capsule (Upgrade D - Read-Only)
+    logger.info('--- 5.2 Verificación de Context Capsule (Read-Only) ---');
+    if (loadedState && loadedState.active_spec) {
+        const { validateContextCapsule } = require('../lib/context-capsule');
+        const capResult = validateContextCapsule(targetDir, loadedState.active_spec);
+        if (capResult.valid) {
+            logger.ok(`Context capsule verificado y fresco (${loadedState.active_spec}/context-capsule.json).`);
+        } else if (capResult.state === 'MISSING') {
+            logger.info(`[LEGACY] No se detectó context-capsule.json en "${loadedState.active_spec}" (Modo Legacy Context-Free).`);
+        } else {
+            for (const f of capResult.findings) {
+                logger.error(`[${f.code}] ${f.message}`);
+                totalErrors++;
+            }
+        }
+    } else {
+        logger.ok('Sin spec activa configurada para verificación de context capsule.');
+    }
+
     // 6. Seguridad Local y Anti-Silent Failures en Tests
     logger.info('--- 6/6 Verificación de Seguridad y Test Runners ---');
     const envPath = fssafe.resolveSafe(targetDir, '.env');

package/src/lib/closure-context.js

@@ -334,6 +334,15 @@ function resolveRelevantFiles(rootPath, featureDir, planBindings, taskList, plan
   if (fs.existsSync(path.join(rootPath, planPath))) filesSet.add(planPath);
   if (fs.existsSync(path.join(rootPath, tasksPath))) filesSet.add(tasksPath);
 
+  const featureLedger = (relFeature + '/cost-ledger.json').replace(/^\.\//, '');
+  if (fs.existsSync(path.join(rootPath, featureLedger))) filesSet.add(featureLedger);
+  if (fs.existsSync(path.join(rootPath, 'cost-ledger.json'))) filesSet.add('cost-ledger.json');
+  if (fs.existsSync(path.join(rootPath, '.gemstack/cost-ledger.json'))) filesSet.add('.gemstack/cost-ledger.json');
+
+  const featureCapsule = (relFeature + '/context-capsule.json').replace(/^\.\//, '');
+  if (fs.existsSync(path.join(rootPath, featureCapsule))) filesSet.add(featureCapsule);
+  if (fs.existsSync(path.join(rootPath, '.gemstack/context-capsule.json'))) filesSet.add('.gemstack/context-capsule.json');
+
   for (const b of (planBindings || [])) {
     if (b.file && fs.existsSync(path.join(rootPath, b.file))) {
       filesSet.add(b.file);