@jaimevalasek/aioson 1.7.0 → 1.8.0

package/src/commands/store-system.js

@@ -0,0 +1,392 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { exists, ensureDir } = require('../utils');
+const { readConfig } = require('./config');
+const { readWorkspace, findProjectRoot } = require('./workspace');
+
+const DEFAULT_BASE_URL = 'https://aioson.com';
+const SYSTEM_PACKAGES_DIR = '.aioson/system-packages';
+const BACKUPS_DIR = '.aioson/.backups';
+
+// Extensions allowed in a system package (Vite React source tree)
+const SYSTEM_ALLOWED_EXTS = new Set([
+  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+  '.json', '.jsonc',
+  '.css', '.scss', '.sass', '.less',
+  '.html',
+  '.svg', '.ico',
+  '.md', '.txt',
+  '.sql',
+  '.env', '.env.example', '.env.template',
+  '.yaml', '.yml',
+  '.toml',
+  '.gitignore',
+]);
+
+// Dirs/files to skip when collecting sources
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', 'dist', 'build', '.turbo', '.next',
+  '.cache', 'coverage', '.nyc_output', 'out',
+  // AIOSON tooling — não faz parte do código-fonte do sistema
+  '.aioson', '.claude', '.gemini', '.codex', 'researchs',
+]);
+
+const SKIP_FILES = new Set([
+  'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml',
+  'bun.lockb',
+]);
+
+const MAX_FILE_BYTES = 512 * 1024;        // 512 KB per file
+const MAX_PACKAGE_BYTES = 20 * 1024 * 1024; // 20 MB total
+
+/**
+ * Parseia lista de emails autorizados a partir de:
+ *   1. Flag CLI --invite="email1,email2,email3" (string com separadores , ; espaço quebra)
+ *   2. Fallback: campo `authorized_emails` no system.json (array ou string)
+ * Devolve array dedup, lowercase, trimmed, validado (contém @).
+ */
+function parseInviteEmails(cliInvite, manifestEmails) {
+  const raw = cliInvite ?? manifestEmails;
+  if (!raw) return [];
+  let parts;
+  if (Array.isArray(raw)) {
+    parts = raw.map(String);
+  } else {
+    parts = String(raw).split(/[,;\s\n]+/);
+  }
+  return Array.from(new Set(
+    parts.map((s) => s.trim().toLowerCase()).filter((s) => s.length > 0 && s.includes('@'))
+  ));
+}
+
+function resolveBaseUrl(config) {
+  return String(config.aiosonBaseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '');
+}
+
+function requireToken(config, t) {
+  const token = config.aiosonToken;
+  if (!token) throw new Error(t('store.error_not_authenticated'));
+  return token;
+}
+
+async function storePost(url, payload, token) {
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      authorization: `Bearer ${token}`,
+      'content-type': 'application/json',
+      accept: 'application/json',
+    },
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(120000),
+  });
+
+  const text = await response.text();
+  let parsed = null;
+  try { parsed = JSON.parse(text); } catch { /* */ }
+
+  if (!response.ok) {
+    const detail = (parsed && parsed.error) ? String(parsed.error) : `${response.status} ${response.statusText}`;
+    throw new Error(`HTTP ${response.status}: ${detail}`);
+  }
+
+  return parsed;
+}
+
+async function storeGet(url, token) {
+  const response = await fetch(url, {
+    headers: { authorization: `Bearer ${token}`, accept: 'application/json' },
+    signal: AbortSignal.timeout(15000),
+  });
+  const text = await response.text();
+  let parsed = null;
+  try { parsed = JSON.parse(text); } catch { /* */ }
+  if (!response.ok) {
+    const detail = (parsed && parsed.error) ? String(parsed.error) : `${response.status} ${response.statusText}`;
+    throw new Error(`HTTP ${response.status}: ${detail}`);
+  }
+  return parsed;
+}
+
+/**
+ * Collect all eligible source files under `dir`.
+ * Returns { relativePath: content } — only text files with allowed extensions.
+ */
+async function collectSystemFiles(dir) {
+  const files = {};
+  let totalBytes = 0;
+  const errors = [];
+
+  async function walk(current, rel) {
+    const entries = await fs.readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      if (SKIP_FILES.has(entry.name)) continue;
+
+      const fullPath = path.join(current, entry.name);
+      const relPath = rel ? `${rel}/${entry.name}` : entry.name;
+
+      if (entry.isDirectory()) {
+        await walk(fullPath, relPath);
+        continue;
+      }
+
+      const ext = entry.name.includes('.')
+        ? `.${entry.name.split('.').pop().toLowerCase()}`
+        : '';
+
+      // Allow dotfiles with no extension (like .gitignore) that match skip list check
+      if (!SYSTEM_ALLOWED_EXTS.has(ext) && ext !== '') continue;
+
+      try {
+        const stat = await fs.stat(fullPath);
+        if (stat.size > MAX_FILE_BYTES) {
+          errors.push(`File too large (skipped): "${relPath}" (${(stat.size / 1024).toFixed(0)} KB)`);
+          continue;
+        }
+        totalBytes += stat.size;
+        if (totalBytes > MAX_PACKAGE_BYTES) {
+          errors.push(`Package exceeds ${MAX_PACKAGE_BYTES / 1024 / 1024} MB limit — stop collecting.`);
+          return;
+        }
+        const content = await fs.readFile(fullPath, 'utf8');
+        files[relPath] = content;
+      } catch {
+        // binary or unreadable — skip silently
+      }
+    }
+  }
+
+  await walk(dir, '');
+  return { files, totalBytes, errors };
+}
+
+/**
+ * Parse and validate system.json.
+ * Returns the parsed manifest or throws.
+ */
+async function readSystemJson(dir, t) {
+  const manifestPath = path.join(dir, 'system.json');
+  if (!(await exists(manifestPath))) {
+    throw new Error(t('system.error_no_manifest', { path: manifestPath }));
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+  } catch {
+    throw new Error(t('system.error_invalid_manifest'));
+  }
+  if (!manifest.slug) throw new Error(t('system.error_manifest_missing_slug'));
+  if (!manifest.version) throw new Error(t('system.error_manifest_missing_version'));
+  if (!manifest.name) throw new Error(t('system.error_manifest_missing_name'));
+  return manifest;
+}
+
+// ── system:package ──────────────────────────────────────────────────────────
+
+async function runSystemPackage({ args, options, logger, t }) {
+  const dir = path.resolve(process.cwd(), args[0] || '.');
+
+  logger.log(t('system.package_reading_manifest'));
+  const manifest = await readSystemJson(dir, t);
+  logger.log(t('system.package_manifest_ok', { slug: manifest.slug, version: manifest.version, name: manifest.name }));
+
+  logger.log(t('system.package_collecting_files'));
+  const { files, totalBytes, errors } = await collectSystemFiles(dir);
+
+  if (errors.length > 0) {
+    for (const e of errors) logger.log(`  [WARN] ${e}`);
+  }
+
+  const fileCount = Object.keys(files).length;
+  logger.log(t('system.package_files_found', { count: fileCount, kb: (totalBytes / 1024).toFixed(1) }));
+
+  if (!files['system.json']) {
+    throw new Error(t('system.error_no_manifest', { path: path.join(dir, 'system.json') }));
+  }
+
+  if (options['dry-run']) {
+    logger.log(t('system.package_dry_run', { slug: manifest.slug, version: manifest.version }));
+    for (const f of Object.keys(files).sort()) logger.log(`  ${f}`);
+    return { ok: true, dryRun: true, manifest, fileCount, totalBytes };
+  }
+
+  // Save package descriptor locally
+  const projectDir = await findProjectRoot(dir);
+  const pkgDir = path.join(projectDir, SYSTEM_PACKAGES_DIR, manifest.slug);
+  await ensureDir(pkgDir);
+
+  const pkgFile = path.join(pkgDir, `${manifest.slug}-${manifest.version}.json`);
+  await fs.writeFile(pkgFile, JSON.stringify({ manifest, files }, null, 2), 'utf8');
+
+  logger.log(t('system.package_saved', { path: pkgFile }));
+  return { ok: true, manifest, fileCount, totalBytes, path: pkgFile };
+}
+
+// ── system:publish ──────────────────────────────────────────────────────────
+
+async function runSystemPublish({ args, options, logger, t }) {
+  const config = await readConfig();
+  const token = requireToken(config, t);
+  const dir = path.resolve(process.cwd(), args[0] || '.');
+
+  logger.log(t('system.publish_reading_manifest'));
+  const manifest = await readSystemJson(dir, t);
+  logger.log(t('system.package_manifest_ok', { slug: manifest.slug, version: manifest.version, name: manifest.name }));
+
+  logger.log(t('system.package_collecting_files'));
+  const { files, totalBytes, errors } = await collectSystemFiles(dir);
+
+  if (errors.length > 0) {
+    for (const e of errors) logger.log(`  [WARN] ${e}`);
+  }
+
+  const fileCount = Object.keys(files).length;
+  logger.log(t('system.package_files_found', { count: fileCount, kb: (totalBytes / 1024).toFixed(1) }));
+
+  // Basic integrity checks
+  if (!files['system.json']) {
+    throw new Error(t('system.error_no_manifest', { path: path.join(dir, 'system.json') }));
+  }
+  if (!files['package.json']) {
+    throw new Error(t('system.error_missing_package_json'));
+  }
+
+  const visibility = options.private ? 'private' : 'public';
+  const paid = Boolean(options.paid);
+  const ws = await readWorkspace(dir);
+
+  // Lista de emails autorizados a instalar quando visibility=private.
+  // Aceita via --invite="email1,email2" OU campo `authorized_emails` no
+  // manifest (system.json). Sem efeito quando visibility !== private.
+  const authorizedEmails = parseInviteEmails(options.invite, manifest.authorized_emails);
+
+  if (options['dry-run']) {
+    logger.log(t('system.publish_dry_run', { slug: manifest.slug, version: manifest.version, visibility }));
+    return { ok: true, dryRun: true, manifest, fileCount, totalBytes, visibility, authorizedEmails };
+  }
+
+  logger.log(t('system.publish_sending'));
+  const baseUrl = resolveBaseUrl(config);
+  const response = await storePost(`${baseUrl}/api/store/systems/publish`, {
+    kind: 'aioson.store.system',
+    slug: manifest.slug,
+    version: manifest.version,
+    files,
+    manifest,
+    visibility,
+    paid,
+    authorizedEmails,
+    workspaceSlug: ws?.slug || null,
+  }, token);
+
+  logger.log(t('system.publish_done', { slug: manifest.slug, url: `${baseUrl}/store/systems/${manifest.slug}` }));
+  logger.log(t('system.publish_summary', { files: fileCount, kb: (totalBytes / 1024).toFixed(1) }));
+  return { ok: true, manifest, fileCount, totalBytes, visibility, paid, response };
+}
+
+// ── system:list ─────────────────────────────────────────────────────────────
+
+async function runSystemList({ args, options, logger, t }) {
+  if (options.remote) {
+    const config = await readConfig();
+    const token = requireToken(config, t);
+    const baseUrl = resolveBaseUrl(config);
+    logger.log(t('list_remote_fetching', { type: 'systems' }));
+    const response = await storeGet(`${baseUrl}/api/store/systems`, token);
+    const systems = response.systems || [];
+    if (systems.length === 0) {
+      logger.log(t('system.list_remote_empty'));
+    } else {
+      logger.log(t('system.list_remote_header', { count: systems.length }));
+      for (const s of systems) {
+        logger.log(t('system.list_remote_item', { slug: s.slug, name: s.name || s.slug, version: s.version || '?', visibility: s.visibility || '?' }));
+      }
+    }
+    return { ok: true, systems, remote: true };
+  }
+
+  // Local: list cached system packages
+  const projectDir = await findProjectRoot(path.resolve(process.cwd(), args[0] || '.'));
+  const pkgsDir = path.join(projectDir, SYSTEM_PACKAGES_DIR);
+
+  if (!(await exists(pkgsDir))) {
+    logger.log(t('system.list_local_empty'));
+    return { ok: true, systems: [] };
+  }
+
+  const entries = await fs.readdir(pkgsDir, { withFileTypes: true });
+  const systems = entries
+    .filter(e => e.isDirectory())
+    .map(e => ({ slug: e.name }));
+
+  if (systems.length === 0) {
+    logger.log(t('system.list_local_empty'));
+  } else {
+    logger.log(t('system.list_local_header', { count: systems.length }));
+    for (const s of systems) {
+      logger.log(t('system.list_local_item', { slug: s.slug }));
+    }
+  }
+
+  return { ok: true, systems };
+}
+
+// ── system:install (developer use — downloads source from store) ─────────────
+
+async function runSystemInstall({ args, options, logger, t }) {
+  const config = await readConfig();
+  const token = requireToken(config, t);
+  const projectDir = await findProjectRoot(path.resolve(process.cwd(), args[0] || '.'));
+  const baseUrl = resolveBaseUrl(config);
+
+  const ref = String(options.slug || options.code || args[1] || '').trim();
+  if (!ref) throw new Error(t('store.error_missing_code_or_slug'));
+
+  logger.log(t('system.install_fetching', { ref }));
+
+  const response = await storePost(`${baseUrl}/api/store/systems/install`, {
+    ref,
+    workspaceSlug: (await readWorkspace(projectDir))?.slug || null,
+  }, token);
+
+  const slug = response.manifest?.slug || response.slug;
+  if (!slug || !response.files) throw new Error(t('store.error_invalid_response'));
+
+  const version = response.manifest?.version || '?';
+  const publisher = response.publisher || 'unknown';
+  logger.log(t('store.install_preview_header', { slug, version, publisher }));
+
+  if (options.inspect) {
+    logger.log(t('store.install_inspect_files', { count: Object.keys(response.files).length }));
+    for (const f of Object.keys(response.files).sort()) logger.log(`  ${f}`);
+    logger.log(t('store.install_inspect_hint'));
+    return { ok: true, slug, inspect: true, files: Object.keys(response.files) };
+  }
+
+  const pkgDir = path.join(projectDir, SYSTEM_PACKAGES_DIR, slug);
+
+  if ((await exists(pkgDir)) && !options.force) {
+    const backupDir = path.join(projectDir, BACKUPS_DIR, `system-packages/${slug}`);
+    logger.log(t('store.install_backing_up', { path: backupDir }));
+    await fs.rm(backupDir, { recursive: true, force: true });
+    await fs.cp(pkgDir, backupDir, { recursive: true });
+    await fs.rm(pkgDir, { recursive: true, force: true });
+  }
+
+  // Write files
+  logger.log(t('system.install_writing'));
+  for (const [relPath, content] of Object.entries(response.files)) {
+    if (typeof content !== 'string') continue;
+    const destPath = path.join(pkgDir, relPath);
+    await ensureDir(path.dirname(destPath));
+    await fs.writeFile(destPath, content, 'utf8');
+  }
+
+  logger.log(t('system.install_done', { slug, path: pkgDir }));
+  return { ok: true, slug, path: pkgDir, manifest: response.manifest };
+}
+
+module.exports = { runSystemPackage, runSystemPublish, runSystemList, runSystemInstall };

package/src/commands/tool-capabilities.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const { TOOL_CAPS, getToolCapabilities, listSupportedTools } = require('../lib/tool-capabilities');
+
+// Expose the per-tool capability map (resume support, install command, etc.)
+// so external clients (AIOSON Play, IDE extensions) can drive UI without
+// hard-coding their own copy of this lookup.
+//
+// Usage:
+//   aioson tool:capabilities --json
+//   aioson tool:capabilities --tool=claude --json
+async function runToolCapabilities({ args: _args, options = {}, logger, t: _t }) {
+  const tool = options.tool ? String(options.tool).trim() : null;
+
+  let payload;
+  if (tool) {
+    const caps = getToolCapabilities(tool);
+    if (!caps) {
+      const supported = listSupportedTools();
+      throw new Error(`tool_unknown:${tool} (supported: ${supported.join(', ')})`);
+    }
+    payload = { tool: tool.toLowerCase(), capabilities: caps };
+  } else {
+    payload = {
+      tools: TOOL_CAPS,
+      schema_version: 1,
+    };
+  }
+
+  if (options.json) {
+    logger.log(JSON.stringify(payload, null, 2));
+    return { ok: true, payload };
+  }
+
+  // Human-readable fallback
+  if (tool) {
+    const caps = payload.capabilities;
+    logger.log(`Tool: ${payload.tool}`);
+    logger.log(`  binary:                ${caps.binary}`);
+    logger.log(`  install_command:       ${caps.install_command}`);
+    logger.log(`  supports_resume:       ${caps.supports_resume}`);
+    if (caps.supports_resume) {
+      logger.log(`  resume_last:           ${(caps.resume_last || []).join(' ')}`);
+      logger.log(`  supports_session_id:   ${caps.supports_session_id}`);
+      if (caps.supports_session_id) {
+        logger.log(`  resume_session_id:     ${(caps.resume_session_id || []).join(' ')}`);
+      }
+      logger.log(`  supports_session_picker: ${caps.supports_session_picker}`);
+      if (caps.supports_session_picker) {
+        logger.log(`  session_picker:        ${(caps.session_picker || []).join(' ')}`);
+      }
+    }
+  } else {
+    logger.log(`Supported tools: ${listSupportedTools().join(', ')}`);
+    logger.log(`Run with --tool=<name> for details, or --json for the full map.`);
+  }
+
+  return { ok: true, payload };
+}
+
+module.exports = {
+  runToolCapabilities,
+};

package/src/commands/update.js

@@ -3,7 +3,7 @@
 const path = require('node:path');
 const { detectFramework } = require('../detector');
 const { updateInstallation } = require('../updater');
-const { validateProjectContextFile } = require('../context');
+const { validateProjectContextFile, getInteractionLanguage } = require('../context');
 const { applyAgentLocale } = require('../locales');
 
 async function runUpdate({ args, options, logger, t }) {
@@ -28,8 +28,8 @@ async function runUpdate({ args, options, logger, t }) {
     const context = await validateProjectContextFile(targetDir);
     const language =
       requestedLanguage ||
-      (context.parsed && context.data && context.data.conversation_language
-        ? context.data.conversation_language
+      (context.parsed && context.data
+        ? getInteractionLanguage(context.data, '')
         : null) ||
       (result.savedProfile && result.savedProfile.locale
         ? result.savedProfile.locale

package/src/commands/verify-gate.js

@@ -454,6 +454,35 @@ async function runVerifyGate({ args, options = {}, logger }) {
   // ── Parse spec requirements ───────────────────────────────────────────────
   const requirements = parseSpecRequirements(specContent);
 
+  // ── Harness Integration ───────────────────────────────────────────────────
+  let contractCriteria = [];
+  if (options.contract) {
+    try {
+      const contractContent = await fs.readFile(path.resolve(targetDir, options.contract), 'utf8');
+      const contract = JSON.parse(contractContent);
+      if (contract.criteria && Array.isArray(contract.criteria)) {
+        contractCriteria = contract.criteria;
+        for (const c of contract.criteria) {
+          let mapped = false;
+          // Map assertion to deterministic check if possible
+          // Pattern mapping: if assertion looks like "path/to/file.js", add to required files
+          if (c.assertion.includes('/') && !c.assertion.includes(' ')) {
+            requirements.required_files.push(c.assertion.trim());
+            mapped = true;
+          }
+          
+          // Only add to acceptance criteria for reporting if not deterministically mapped
+          // This prevents "Unchecked criterion" issues for things already checked via files/patterns
+          if (!mapped) {
+            requirements.acceptance_criteria.push({ text: `[Harness ${c.id}] ${c.description}`, checked: false });
+          }
+        }
+      }
+    } catch (err) {
+      logger.warn(`[VerifyGate] Falha ao ler contrato: ${err.message}`);
+    }
+  }
+
   // ── Collect artifact files ────────────────────────────────────────────────
   const allFiles = await collectFiles(artifactPath);
 
@@ -499,6 +528,16 @@ async function runVerifyGate({ args, options = {}, logger }) {
   const relOut = path.relative(targetDir, outPath);
 
   if (options.json) {
+    // Map issues/passes back to contract IDs if possible
+    const criteriaResults = contractCriteria.map(c => {
+      const passed = !allIssues.some(i => i.includes(c.id) || i.includes(c.assertion));
+      return {
+        id: c.id,
+        passed,
+        reason: passed ? null : allIssues.find(i => i.includes(c.id) || i.includes(c.assertion))
+      };
+    });
+
     return {
       ok: verdict === 'PASS' || verdict === 'PASS_WITH_NOTES',
       verdict,
@@ -509,6 +548,7 @@ async function runVerifyGate({ args, options = {}, logger }) {
       issues: allIssues,
       notes: allNotes,
       passes: allPasses,
+      criteria_results: criteriaResults,
       requirements: {
         required_files: requirements.required_files.length,
         acceptance_criteria: requirements.acceptance_criteria.length,