@jaimevalasek/aioson 1.7.0 → 1.8.0

package/src/commands/harness.js

@@ -0,0 +1,121 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { createCircuitBreaker } = require('../harness/circuit-breaker');
+
+/**
+ * aioson harness:init — Inicializa o contrato e progresso da feature.
+ */
+async function runHarnessInit({ args, options = {}, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const slug = String(options.slug || '').trim();
+  const mode = String(options.mode || 'BALANCED').toUpperCase();
+
+  if (!slug) {
+    logger.error(t('errors.missing_slug') || 'Error: --slug is required');
+    return { ok: false, error: 'missing_slug' };
+  }
+
+  const planDir = path.join(targetDir, '.aioson', 'plans', slug);
+  const contractPath = path.join(planDir, 'harness-contract.json');
+  const progressPath = path.join(planDir, 'progress.json');
+
+  if (fs.existsSync(contractPath) || fs.existsSync(progressPath)) {
+    logger.log(t('harness.init_exists', { path: path.relative(targetDir, planDir) }) || `Harness already initialized in ${path.relative(targetDir, planDir)}`);
+    return { ok: true, skipped: true };
+  }
+
+  if (!fs.existsSync(planDir)) {
+    fs.mkdirSync(planDir, { recursive: true });
+  }
+
+  const contract = {
+    feature: slug,
+    contract_mode: mode,
+    governor: {
+      max_steps: 50,
+      error_streak_limit: 5,
+      cost_ceiling_tokens: null
+    },
+    criteria: [
+      {
+        id: "C1",
+        description: "Estrutura de arquivos e sintaxe básica",
+        assertion: "all files exist and parse",
+        binary: true
+      }
+    ]
+  };
+
+  const cb = createCircuitBreaker(contractPath, progressPath);
+  // cb.load() vai criar o progress inicial se não existir
+  fs.writeFileSync(contractPath, JSON.stringify(contract, null, 2), 'utf8');
+  await cb.load();
+  await cb._save(); // Garante a criação do progress.json inicial
+
+  logger.log(t('harness.init_success', { slug }) || `Harness initialized for feature: ${slug}`);
+  return { ok: true, slug, path: planDir };
+}
+
+/**
+ * aioson harness:validate — Executa validação manual e atualiza progresso.
+ */
+async function runHarnessValidate({ args, options = {}, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const slug = String(options.slug || '').trim();
+  const artifact = options.artifact ? String(options.artifact).trim() : null;
+
+  if (!slug) {
+    logger.error(t('errors.missing_slug') || 'Error: --slug is required');
+    return { ok: false, error: 'missing_slug' };
+  }
+
+  const contractPath = path.join(targetDir, '.aioson', 'plans', slug, 'harness-contract.json');
+  const progressPath = path.join(targetDir, '.aioson', 'plans', slug, 'progress.json');
+
+  if (!fs.existsSync(contractPath)) {
+    logger.error(t('harness.contract_not_found') || `Contract not found for slug: ${slug}`);
+    return { ok: false, error: 'contract_not_found' };
+  }
+
+  const cb = createCircuitBreaker(contractPath, progressPath);
+  await cb.load();
+
+  const { allowed, reason } = cb.check();
+  if (!allowed) {
+    logger.log(t('harness.blocked', { reason }) || `Execution paused: ${reason}`);
+    return { ok: false, reason };
+  }
+
+  logger.log(t('harness.validating', { slug }) || `Validating harness for ${slug}...`);
+
+  // NOTA: No Slice 2 faremos o upgrade do verify-gate para suportar --contract.
+  // Por enquanto, chamamos o verify:gate via shell (subprocesso) como planejado na arquitetura.
+  const { execSync } = require('node:child_process');
+  
+  try {
+    const specPath = path.join(targetDir, '.aioson', 'context', `spec-${slug}.md`);
+    const cmd = `aioson verify:gate . --spec="${specPath}" --contract="${contractPath}" ${artifact ? `--artifact="${artifact}"` : ''} --json`;
+    
+    const output = execSync(cmd, { cwd: targetDir, encoding: 'utf8' });
+    const result = JSON.parse(output);
+
+    if (result.verdict === 'PASS' || result.verdict === 'PASS_WITH_NOTES') {
+      await cb.recordSuccess();
+      logger.log(`  ✓ PASS — ${slug}`);
+      return { ok: true, verdict: result.verdict };
+    } else {
+      const firstIssue = result.issues?.[0]?.message || result.verdict;
+      await cb.recordError(firstIssue);
+      logger.log(`  ✗ ${result.verdict} — ${firstIssue}`);
+      return { ok: false, verdict: result.verdict, error: firstIssue };
+    }
+  } catch (err) {
+    await cb.recordError(err.message.slice(0, 100));
+    logger.error(`  ✗ Error during validation: ${err.message}`);
+    return { ok: false, error: err.message };
+  }
+}
+
+module.exports = { runHarnessInit, runHarnessValidate };

package/src/commands/implementation-plan.js

@@ -15,6 +15,7 @@ const {
 } = require('../runtime-store');
 
 const CONTEXT_DIR = path.join('.aioson', 'context');
+const PLANS_DIR = path.join('.aioson', 'plans');
 
 async function pathExists(targetPath) {
   try {
@@ -25,6 +26,26 @@ async function pathExists(targetPath) {
   }
 }
 
+/**
+ * Resolve the best path for an implementation plan given a slug.
+ */
+async function resolvePlanPath(projectDir, featureSlug) {
+  if (featureSlug) {
+    // 1. Try new structured directory: .aioson/plans/{slug}/manifest.md
+    const structuredPath = path.join(projectDir, PLANS_DIR, featureSlug, 'manifest.md');
+    if (await pathExists(structuredPath)) return structuredPath;
+
+    // 2. Try legacy flat file: .aioson/context/implementation-plan-{slug}.md
+    const legacyPath = path.join(projectDir, CONTEXT_DIR, `implementation-plan-${featureSlug}.md`);
+    if (await pathExists(legacyPath)) return legacyPath;
+
+    return structuredPath; // default to new structure even if missing
+  }
+
+  // No slug -> implementation-plan.md in context
+  return path.join(projectDir, CONTEXT_DIR, 'implementation-plan.md');
+}
+
 /**
  * Compute a simple hash of an array of files for staleness detection.
  */
@@ -47,7 +68,10 @@ async function computeSourceHash(projectDir, filePaths) {
  */
 async function detectPlanFiles(projectDir) {
   const contextDir = path.resolve(projectDir, CONTEXT_DIR);
+  const plansDir = path.resolve(projectDir, PLANS_DIR);
   const plans = [];
+
+  // Scan context (legacy/simple)
   try {
     const files = await fs.readdir(contextDir);
     for (const f of files) {
@@ -55,12 +79,24 @@ async function detectPlanFiles(projectDir) {
         const slug = f === 'implementation-plan.md'
           ? null
           : f.replace('implementation-plan-', '').replace('.md', '');
-        plans.push({ file: f, featureSlug: slug, path: path.join(CONTEXT_DIR, f) });
+        plans.push({ file: f, featureSlug: slug, path: path.join(CONTEXT_DIR, f), type: 'legacy' });
       }
     }
-  } catch {
-    // context dir may not exist
-  }
+  } catch { /* ignore */ }
+
+  // Scan structured plans
+  try {
+    const entries = await fs.readdir(plansDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const manifest = path.join(plansDir, entry.name, 'manifest.md');
+        if (await pathExists(manifest)) {
+          plans.push({ file: 'manifest.md', featureSlug: entry.name, path: path.join(PLANS_DIR, entry.name, 'manifest.md'), type: 'structured' });
+        }
+      }
+    }
+  } catch { /* ignore */ }
+
   return plans;
 }
 
@@ -95,13 +131,10 @@ function countPhases(content) {
  * Shows the current implementation plan.
  */
 async function handleShow(projectDir, featureSlug, { logger, t }) {
-  const fileName = featureSlug
-    ? `implementation-plan-${featureSlug}.md`
-    : 'implementation-plan.md';
-  const planPath = path.resolve(projectDir, CONTEXT_DIR, fileName);
+  const planPath = await resolvePlanPath(projectDir, featureSlug);
 
   if (!(await pathExists(planPath))) {
-    logger.error(t('implementation_plan.not_found', { file: fileName }));
+    logger.error(t('implementation_plan.not_found', { file: path.basename(planPath) }));
     return { found: false };
   }
 
@@ -109,7 +142,7 @@ async function handleShow(projectDir, featureSlug, { logger, t }) {
   const meta = parsePlanFrontmatter(content);
   const phases = countPhases(content);
 
-  logger.log(`Plan: ${fileName}`);
+  logger.log(`Plan: ${path.basename(planPath)}`);
   logger.log(`Status: ${meta.status || 'unknown'}`);
   logger.log(`Classification: ${meta.classification || 'unknown'}`);
   logger.log(`Phases: ${phases}`);
@@ -199,13 +232,10 @@ async function handleCheckpoint(projectDir, featureSlug, phaseNumber, { logger,
  * Checks if source artifacts changed after the plan was created.
  */
 async function handleStale(projectDir, featureSlug, { logger, t }) {
-  const fileName = featureSlug
-    ? `implementation-plan-${featureSlug}.md`
-    : 'implementation-plan.md';
-  const planPath = path.resolve(projectDir, CONTEXT_DIR, fileName);
+  const planPath = await resolvePlanPath(projectDir, featureSlug);
 
   if (!(await pathExists(planPath))) {
-    logger.error(t('implementation_plan.not_found', { file: fileName }));
+    logger.error(t('implementation_plan.not_found', { file: path.basename(planPath) }));
     return { found: false, stale: false };
   }
 
@@ -248,13 +278,10 @@ async function handleStale(projectDir, featureSlug, { logger, t }) {
  * Registers an existing plan file into the runtime SQLite.
  */
 async function handleRegister(projectDir, featureSlug, { logger, t }) {
-  const fileName = featureSlug
-    ? `implementation-plan-${featureSlug}.md`
-    : 'implementation-plan.md';
-  const planPath = path.resolve(projectDir, CONTEXT_DIR, fileName);
+  const planPath = await resolvePlanPath(projectDir, featureSlug);
 
   if (!(await pathExists(planPath))) {
-    logger.error(t('implementation_plan.not_found', { file: fileName }));
+    logger.error(t('implementation_plan.not_found', { file: path.basename(planPath) }));
     return { registered: false };
   }
 

package/src/commands/init.js

@@ -3,7 +3,7 @@
 const fs = require('node:fs/promises');
 const path = require('node:path');
 const { installTemplate } = require('../installer');
-const { applyAgentLocale } = require('../locales');
+const { applyAgentLocale, normalizeInteractionLanguage } = require('../locales');
 const { resolvePromptTool } = require('../prompt-tool');
 const { runInstallWizard } = require('../install-wizard');
 const { renderRevealAnimation, renderInstallSummary, renderProgress } = require('../install-animation');
@@ -73,7 +73,11 @@ async function runInit({ args, options, logger, t }) {
   const effectiveLocale = requestedLanguage || (installProfile && installProfile.locale) || null;
   let localeApply = null;
   if (effectiveLocale) {
-    localeApply = await applyAgentLocale(targetDir, effectiveLocale, { dryRun });
+    localeApply = await applyAgentLocale(
+      targetDir,
+      normalizeInteractionLanguage(effectiveLocale),
+      { dryRun }
+    );
     if (dryRun) {
       logger.log(t('locale_apply.dry_run_applied', { locale: localeApply.locale }));
     } else {

package/src/commands/install.js

@@ -3,7 +3,7 @@
 const path = require('node:path');
 const { detectFramework } = require('../detector');
 const { installTemplate, readInstallProfile } = require('../installer');
-const { applyAgentLocale } = require('../locales');
+const { applyAgentLocale, normalizeInteractionLanguage } = require('../locales');
 const { resolvePromptTool } = require('../prompt-tool');
 const { runInstallWizard } = require('../install-wizard');
 const { renderRevealAnimation, renderInstallSummary, renderProgress } = require('../install-animation');
@@ -63,7 +63,11 @@ async function runInstall({ args, options, logger, t }) {
   const effectiveLocale = requestedLanguage || (installProfile && installProfile.locale) || null;
   let localeApply = null;
   if (effectiveLocale) {
-    localeApply = await applyAgentLocale(targetDir, effectiveLocale, { dryRun });
+    localeApply = await applyAgentLocale(
+      targetDir,
+      normalizeInteractionLanguage(effectiveLocale),
+      { dryRun }
+    );
     if (dryRun) {
       logger.log(t('locale_apply.dry_run_applied', { locale: localeApply.locale }));
     } else {