@jaimevalasek/aioson 1.7.2 → 1.9.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/sync-agents-preflight.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * sync-agents-preflight — guard rsync against wiping unpropagated workspace edits.
+ *
+ * Runs before `npm run sync:agents` (which copies template/ → workspace).
+ * For each chain agent, extracts the `## Feature dossier` section from both
+ * `.aioson/agents/{agent}.md` and `template/.aioson/agents/{agent}.md`, then
+ * aborts with exit 1 if the workspace section is *longer* than the template
+ * section — that means the workspace has edits that have not been propagated
+ * back to the template, and rsync would silently overwrite them.
+ *
+ * If the workspace and template are equal, or the template is longer, the
+ * preflight allows rsync to continue.
+ *
+ * Run programmatically via `node src/commands/sync-agents-preflight.js`.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { CHAIN_AGENTS, FEATURE_DOSSIER_HEADER, extractSection } = require('./dossier-audit');
+const dossierTelemetry = require('../lib/dossier-telemetry');
+
+// Active Learning Loop Phase 6 — workspace ↔ template parity checks for the
+// `.aioson/` artifacts this feature ships. Phase 1 dev's documented decision
+// (spec Agent Trail) confirmed `template/src/` does not exist by design: the
+// CLI lives in `src/` only, and `template/` mirrors `.aioson/` artifacts
+// (config, agents, docs, rules, brains, context). Phase 6 parity therefore
+// targets the template `.aioson/` surface that active-learning-loop touches.
+const LEARNING_LOOP_TIER1_COMMANDS = ['context:load', 'memory:search'];
+const LEARNING_LOOP_TIER2_COMMANDS = ['memory:archive', 'memory:restore'];
+const LEARNING_LOOP_ARCHIVE_PLACEHOLDERS = [
+  '.aioson/rules/_archived/.gitkeep',
+  '.aioson/brains/_archived/.gitkeep',
+  '.aioson/context/_archived/.gitkeep'
+];
+
+function readFileOrEmpty(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function checkLearningLoopTemplateParity(projectRoot) {
+  const issues = [];
+  const templateDir = path.join(projectRoot, 'template');
+
+  // 1. template/.aioson/config/learning-loop.json must exist + be valid JSON.
+  const cfgPath = path.join(templateDir, '.aioson', 'config', 'learning-loop.json');
+  const cfgRaw = readFileOrEmpty(cfgPath);
+  if (!cfgRaw) {
+    issues.push({ kind: 'missing_config', path: 'template/.aioson/config/learning-loop.json' });
+  } else {
+    let cfg;
+    try { cfg = JSON.parse(cfgRaw); }
+    catch (err) {
+      issues.push({ kind: 'invalid_config_json', path: 'template/.aioson/config/learning-loop.json', error: err.message });
+      cfg = null;
+    }
+    if (cfg) {
+      for (const key of ['enabled', 'skip_on_classification', 'execution_mode', 'lock_strategy', 'timeout_ms']) {
+        if (!(key in cfg)) {
+          issues.push({ kind: 'config_missing_key', key });
+        }
+      }
+    }
+  }
+
+  // 2. template/.aioson/config/autonomy-protocol.json must list the verbs.
+  const autonomyPath = path.join(templateDir, '.aioson', 'config', 'autonomy-protocol.json');
+  const autonomyRaw = readFileOrEmpty(autonomyPath);
+  if (!autonomyRaw) {
+    issues.push({ kind: 'missing_autonomy', path: 'template/.aioson/config/autonomy-protocol.json' });
+  } else {
+    let autonomy;
+    try { autonomy = JSON.parse(autonomyRaw); }
+    catch (err) {
+      issues.push({ kind: 'invalid_autonomy_json', error: err.message });
+      autonomy = null;
+    }
+    if (autonomy && autonomy.tiers) {
+      const tier1 = (autonomy.tiers.tier1_silent && autonomy.tiers.tier1_silent.aioson_commands) || [];
+      const tier2 = (autonomy.tiers.tier2_notified && autonomy.tiers.tier2_notified.aioson_commands) || [];
+      for (const verb of LEARNING_LOOP_TIER1_COMMANDS) {
+        if (!tier1.includes(verb)) issues.push({ kind: 'autonomy_tier1_missing', verb });
+      }
+      for (const verb of LEARNING_LOOP_TIER2_COMMANDS) {
+        if (!tier2.includes(verb)) issues.push({ kind: 'autonomy_tier2_missing', verb });
+      }
+    }
+  }
+
+  // 3. Archive folder placeholders must exist in the template tree.
+  for (const rel of LEARNING_LOOP_ARCHIVE_PLACEHOLDERS) {
+    const absPath = path.join(templateDir, rel);
+    if (!fs.existsSync(absPath)) {
+      issues.push({ kind: 'archive_placeholder_missing', path: `template/${rel}` });
+    }
+  }
+
+  return issues;
+}
+
+function checkParity(projectRoot) {
+  const violations = [];
+  for (const agent of CHAIN_AGENTS) {
+    const workspacePath = path.join(projectRoot, '.aioson', 'agents', `${agent}.md`);
+    const templatePath = path.join(projectRoot, 'template', '.aioson', 'agents', `${agent}.md`);
+    const workspaceRaw = readFileOrEmpty(workspacePath);
+    const templateRaw = readFileOrEmpty(templatePath);
+    if (!workspaceRaw && !templateRaw) continue;
+
+    const workspaceSection = workspaceRaw ? extractSection(workspaceRaw, FEATURE_DOSSIER_HEADER) : null;
+    const templateSection = templateRaw ? extractSection(templateRaw, FEATURE_DOSSIER_HEADER) : null;
+
+    if (workspaceSection === templateSection) continue;
+
+    const workspaceLen = workspaceSection ? workspaceSection.length : 0;
+    const templateLen = templateSection ? templateSection.length : 0;
+
+    if (workspaceLen > templateLen) {
+      violations.push({ agent, workspaceLen, templateLen });
+    }
+  }
+  return violations;
+}
+
+async function main(projectRoot = process.cwd()) {
+  const violations = checkParity(projectRoot);
+  const learningLoopIssues = checkLearningLoopTemplateParity(projectRoot);
+
+  if (violations.length === 0 && learningLoopIssues.length === 0) {
+    return 0;
+  }
+
+  if (violations.length > 0) {
+    process.stderr.write('[sync:agents BLOCKED] Workspace has Feature dossier edits not propagated to template:\n');
+    for (const v of violations) {
+      process.stderr.write(`  - @${v.agent}: workspace=${v.workspaceLen} chars, template=${v.templateLen} chars\n`);
+    }
+    process.stderr.write('\nCopy workspace → template for these agents before running sync:agents,\n');
+    process.stderr.write('otherwise rsync will overwrite the workspace edits.\n');
+
+    await dossierTelemetry.emitDossierEvent(projectRoot, {
+      agent: 'sync-agents-preflight',
+      type: 'sync_agents_parity_violation',
+      summary: `${violations.length} agent(s) ahead in workspace`,
+      meta: { violations }
+    });
+  }
+
+  if (learningLoopIssues.length > 0) {
+    process.stderr.write('[sync:agents BLOCKED] Active Learning Loop template parity issues:\n');
+    for (const issue of learningLoopIssues) {
+      process.stderr.write(`  - ${issue.kind}${issue.path ? ' (' + issue.path + ')' : ''}${issue.verb ? ' (' + issue.verb + ')' : ''}${issue.key ? ' (' + issue.key + ')' : ''}${issue.error ? ': ' + issue.error : ''}\n`);
+    }
+    await dossierTelemetry.emitDossierEvent(projectRoot, {
+      agent: 'sync-agents-preflight',
+      type: 'learning_loop_template_parity_violation',
+      summary: `${learningLoopIssues.length} learning-loop template issue(s)`,
+      meta: { issues: learningLoopIssues }
+    });
+  }
+
+  return 1;
+}
+
+if (require.main === module) {
+  main().then((code) => process.exit(code));
+}
+
+module.exports = { checkParity, checkLearningLoopTemplateParity, main };