@jaimevalasek/aioson 1.3.0

package/src/locales.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { AGENT_DEFINITIONS } = require('./constants');
+const { exists, ensureDir } = require('./utils');
+
+const SUPPORTED_AGENT_LOCALES = ['en', 'pt-BR', 'es', 'fr'];
+
+function normalizeLanguageTag(value) {
+  return String(value || '').trim();
+}
+
+function localeForPath(value) {
+  return String(value || '').replace(/_/g, '-');
+}
+
+function resolveAgentLocale(languageTag) {
+  const tag = normalizeLanguageTag(languageTag);
+  if (!tag) return 'en';
+  const canonical = tag.replace(/_/g, '-');
+
+  const exact = SUPPORTED_AGENT_LOCALES.find(
+    (locale) => locale.toLowerCase() === canonical.toLowerCase()
+  );
+  if (exact) return exact;
+
+  const base = canonical.split('-')[0].toLowerCase();
+  if (base === 'pt') return 'pt-BR';
+  if (base === 'en') return 'en';
+  if (base === 'es') return 'es';
+  if (base === 'fr') return 'fr';
+
+  return 'en';
+}
+
+function getLocalizedAgentPath(agentId, locale) {
+  return `.aioson/locales/${localeForPath(locale)}/agents/${agentId}.md`;
+}
+
+function getActiveAgentPath(agentId) {
+  return `.aioson/agents/${agentId}.md`;
+}
+
+async function applyAgentLocale(targetDir, locale, options = {}) {
+  const resolved = resolveAgentLocale(locale);
+  const dryRun = Boolean(options.dryRun);
+  const copied = [];
+  const missing = [];
+
+  for (const agent of AGENT_DEFINITIONS) {
+    const sourceRel = getLocalizedAgentPath(agent.id, resolved);
+    const destRel = getActiveAgentPath(agent.id);
+    const sourceAbs = path.join(targetDir, sourceRel);
+    const destAbs = path.join(targetDir, destRel);
+
+    if (!(await exists(sourceAbs))) {
+      missing.push(sourceRel);
+      continue;
+    }
+
+    if (!dryRun) {
+      await ensureDir(path.dirname(destAbs));
+      await fs.copyFile(sourceAbs, destAbs);
+    }
+    copied.push({ source: sourceRel, target: destRel });
+  }
+
+  return {
+    locale: resolved,
+    copied,
+    missing,
+    dryRun
+  };
+}
+
+module.exports = {
+  SUPPORTED_AGENT_LOCALES,
+  normalizeLanguageTag,
+  resolveAgentLocale,
+  getLocalizedAgentPath,
+  getActiveAgentPath,
+  applyAgentLocale
+};

package/src/onboarding.js

@@ -0,0 +1,305 @@
+'use strict';
+
+const BACKEND_CHOICES = {
+  '1': 'Laravel',
+  '2': 'Rails',
+  '3': 'Django',
+  '4': 'Node/Express',
+  '5': 'Next.js',
+  '6': 'Nuxt',
+  '7': 'Hardhat',
+  '8': 'Foundry',
+  '9': 'Truffle',
+  '10': 'Anchor',
+  '11': 'Solana Web3',
+  '12': 'Cardano',
+  '13': 'Other'
+};
+
+const FRONTEND_CHOICES = {
+  '1': 'TALL Stack',
+  '2': 'VILT Stack',
+  '3': 'Blade',
+  '4': 'Next.js',
+  '5': 'Nuxt',
+  '6': 'React',
+  '7': 'Vue',
+  '8': 'Other'
+};
+
+const AUTH_CHOICES = {
+  '1': 'Breeze',
+  '2': 'Jetstream + Livewire',
+  '3': 'Filament Shield',
+  '4': 'Custom'
+};
+
+const UIUX_CHOICES = {
+  '1': 'Tailwind',
+  '2': 'Flux UI',
+  '3': 'shadcn/ui',
+  '4': 'Filament'
+};
+
+const DATABASE_CHOICES = {
+  '1': 'MySQL',
+  '2': 'PostgreSQL',
+  '3': 'SQLite',
+  '4': 'MongoDB',
+  '5': 'Supabase',
+  '6': 'PlanetScale'
+};
+
+const SERVICE_CHOICES = {
+  queues: 'Queues (Redis/Horizon)',
+  storage: 'Storage (S3-compatible)',
+  websockets: 'WebSockets',
+  payments: 'Payments',
+  email: 'Transactional Email',
+  cache: 'Cache (Redis)',
+  search: 'Full-text Search'
+};
+
+const SERVICE_ALIASES = {
+  queues: ['queues', 'queue', 'horizon', 'redis queue', 'redis'],
+  storage: ['storage', 's3', 'r2', 'object storage'],
+  websockets: ['websockets', 'websocket', 'reverb', 'pusher'],
+  payments: ['payments', 'payment', 'stripe', 'mercadopago', 'pagseguro'],
+  email: ['email', 'transactional email', 'mailgun', 'resend', 'ses'],
+  cache: ['cache', 'redis cache'],
+  search: ['search', 'full-text', 'full text', 'meilisearch', 'algolia']
+};
+
+const PROFILE_CHOICES = {
+  '1': 'developer',
+  '2': 'beginner',
+  '3': 'team'
+};
+
+function normalizeText(value) {
+  return String(value || '').trim();
+}
+
+function normalizeChoice(value, choices, fallback = '') {
+  const input = normalizeText(value);
+  if (!input) return fallback;
+  if (Object.prototype.hasOwnProperty.call(choices, input)) {
+    return choices[input];
+  }
+
+  const lowerInput = input.toLowerCase();
+  for (const selected of Object.values(choices)) {
+    if (selected.toLowerCase() === lowerInput) return selected;
+  }
+  return input;
+}
+
+function normalizeProfile(value, fallback = 'developer') {
+  const input = normalizeText(value);
+  if (!input) return fallback;
+  if (Object.prototype.hasOwnProperty.call(PROFILE_CHOICES, input)) {
+    return PROFILE_CHOICES[input];
+  }
+  const lower = input.toLowerCase();
+  if (['developer', 'beginner', 'team'].includes(lower)) return lower;
+  return fallback;
+}
+
+function parseServices(input) {
+  const text = normalizeText(input);
+  if (!text) return [];
+  return text
+    .split(',')
+    .map((item) => item.trim().toLowerCase())
+    .filter(Boolean)
+    .map((token) => {
+      const canonical = Object.entries(SERVICE_ALIASES).find(([, aliases]) =>
+        aliases.includes(token)
+      );
+      if (canonical) {
+        return SERVICE_CHOICES[canonical[0]];
+      }
+      return SERVICE_CHOICES[token] || token;
+    })
+    .filter((value, index, arr) => arr.indexOf(value) === index);
+}
+
+function inferProjectTypeFromFramework(framework) {
+  const value = normalizeText(framework).toLowerCase();
+  if (['hardhat', 'foundry', 'truffle', 'anchor', 'solana web3', 'cardano'].includes(value)) {
+    return 'dapp';
+  }
+  return 'web_app';
+}
+
+function inferWeb3NetworkFromFramework(framework) {
+  const value = normalizeText(framework).toLowerCase();
+  if (['hardhat', 'foundry', 'truffle'].includes(value)) return 'ethereum';
+  if (['anchor', 'solana web3'].includes(value)) return 'solana';
+  if (value === 'cardano') return 'cardano';
+  return '';
+}
+
+function buildDeveloperProfile(input) {
+  const backend = normalizeChoice(
+    input.backendChoice,
+    BACKEND_CHOICES,
+    input.backend || input.framework || 'Laravel'
+  );
+  const frontend = normalizeChoice(input.frontendChoice, FRONTEND_CHOICES, input.frontend || '');
+  const auth = normalizeChoice(input.authChoice, AUTH_CHOICES, input.auth || '');
+  const uiux = normalizeChoice(input.uiuxChoice, UIUX_CHOICES, input.uiux || '');
+  const database = normalizeChoice(input.databaseChoice, DATABASE_CHOICES, input.database || '');
+  const services = parseServices(input.servicesChoice || input.services || '');
+  const laravelVersion = normalizeText(input.laravelVersion);
+  const teamsEnabled = input.teamsEnabled === true;
+
+  const backendValue =
+    backend === 'Other'
+      ? normalizeText(input.backend || input.framework) || 'Custom backend'
+      : backend;
+  const frontendValue =
+    frontend === 'Other'
+      ? normalizeText(input.frontendText || input.frontend) || 'Custom frontend'
+      : frontend;
+  const framework = backendValue === 'Laravel' && laravelVersion ? `Laravel ${laravelVersion}` : backendValue;
+  const projectType = inferProjectTypeFromFramework(backendValue);
+  const web3Network = inferWeb3NetworkFromFramework(backendValue);
+
+  const notes = [];
+  if (backend === 'Laravel' && auth === 'Jetstream + Livewire') {
+    notes.push(`Jetstream teams: ${teamsEnabled ? 'enabled' : 'disabled'}`);
+  }
+  if (services.length > 0) {
+    notes.push(`Selected services: ${services.join(', ')}`);
+  }
+
+  return {
+    profile: 'developer',
+    projectType,
+    framework,
+    backend: backendValue,
+    frontend: frontendValue,
+    auth,
+    uiux,
+    database,
+    services,
+    web3Enabled: projectType === 'dapp',
+    web3Networks: web3Network,
+    contractFramework: projectType === 'dapp' ? backendValue : '',
+    notes
+  };
+}
+
+function recommendBeginnerProfile(input = {}) {
+  const expectedUsers = normalizeText(input.expectedUsers).toLowerCase();
+  const mobileNeed = normalizeText(input.mobileRequirement).toLowerCase();
+  const hosting = normalizeText(input.hostingPreference).toLowerCase();
+  const summary = normalizeText(input.projectSummary);
+
+  const recommendation = {
+    profile: 'beginner',
+    projectType: 'web_app',
+    framework: 'Laravel',
+    backend: 'Laravel',
+    frontend: 'TALL Stack',
+    auth: 'Jetstream + Livewire',
+    uiux: 'Flux UI',
+    database: 'SQLite',
+    services: [],
+    web3Enabled: false,
+    web3Networks: '',
+    contractFramework: '',
+    notes: []
+  };
+
+  if (expectedUsers === '2' || expectedUsers.includes('small')) {
+    recommendation.database = 'MySQL';
+  }
+  if (expectedUsers === '3' || expectedUsers.includes('external')) {
+    recommendation.database = 'PostgreSQL';
+    recommendation.services.push('Queues (Redis/Horizon)');
+    recommendation.services.push('Transactional Email');
+  }
+
+  if (mobileNeed === '1' || mobileNeed.includes('app')) {
+    recommendation.frontend = 'Next.js';
+    recommendation.notes.push('Mobile-first requirement detected; consider React Native/Expo as follow-up.');
+  }
+
+  if (hosting === '2' || hosting.includes('vps')) {
+    recommendation.notes.push('VPS preference detected; keep deployment scripts simple and reproducible.');
+  }
+  if (hosting === '3' || hosting.includes('cloud')) {
+    recommendation.database = recommendation.database === 'SQLite' ? 'PostgreSQL' : recommendation.database;
+    recommendation.services.push('Storage (S3-compatible)');
+    recommendation.notes.push('Cloud profile detected; use managed DB and object storage from day one.');
+  }
+
+  if (/wallet|token|nft|blockchain|web3|smart contract/i.test(summary)) {
+    recommendation.projectType = 'dapp';
+    recommendation.framework = 'Hardhat';
+    recommendation.backend = 'Hardhat';
+    recommendation.frontend = 'Next.js';
+    recommendation.auth = 'Custom';
+    recommendation.database = 'PostgreSQL';
+    recommendation.web3Enabled = true;
+    recommendation.web3Networks = 'ethereum';
+    recommendation.contractFramework = 'Hardhat';
+    recommendation.services = ['Payments', 'Cache (Redis)'];
+    recommendation.notes.push('Web3 terms detected; dApp starter recommendation applied.');
+  }
+
+  recommendation.services = recommendation.services.filter(
+    (value, index, arr) => arr.indexOf(value) === index
+  );
+  recommendation.notes.push('This recommendation is a starter profile; adjust once requirements are clearer.');
+  return recommendation;
+}
+
+function buildTeamProfile(input = {}) {
+  const framework = normalizeText(input.framework || input.backend || 'Node/Express');
+  const projectType = normalizeChoice(
+    input.projectType,
+    { web_app: 'web_app', dapp: 'dapp', api: 'api', site: 'site', script: 'script' },
+    inferProjectTypeFromFramework(framework)
+  );
+  const web3Enabled = projectType === 'dapp' || String(input.web3Enabled).toLowerCase() === 'true';
+  return {
+    profile: 'team',
+    projectType,
+    framework,
+    backend: normalizeText(input.backend || framework),
+    frontend: normalizeText(input.frontend || ''),
+    auth: normalizeText(input.auth || ''),
+    uiux: normalizeText(input.uiux || ''),
+    database: normalizeText(input.database || ''),
+    services: parseServices(input.services || ''),
+    web3Enabled,
+    web3Networks: normalizeText(
+      input.web3Networks || (web3Enabled ? inferWeb3NetworkFromFramework(framework) : '')
+    ),
+    contractFramework: normalizeText(
+      input.contractFramework || (web3Enabled ? framework : '')
+    ),
+    notes: ['Team profile selected; preserve explicit team conventions and CI rules.']
+  };
+}
+
+module.exports = {
+  BACKEND_CHOICES,
+  FRONTEND_CHOICES,
+  AUTH_CHOICES,
+  UIUX_CHOICES,
+  DATABASE_CHOICES,
+  PROFILE_CHOICES,
+  SERVICE_CHOICES,
+  normalizeChoice,
+  normalizeProfile,
+  parseServices,
+  inferProjectTypeFromFramework,
+  inferWeb3NetworkFromFramework,
+  buildDeveloperProfile,
+  recommendBeginnerProfile,
+  buildTeamProfile
+};

package/src/parser.js

@@ -0,0 +1,53 @@
+'use strict';
+
+function parseArgv(argv) {
+  const [, , ...tokens] = argv;
+  const args = [];
+  const options = {};
+  let command = 'help';
+
+  for (let i = 0; i < tokens.length; i += 1) {
+    const token = tokens[i];
+
+    if (token.startsWith('--')) {
+      const [k, v] = token.replace(/^--/, '').split('=');
+      if (v !== undefined) {
+        options[k] = v;
+        continue;
+      }
+
+      const next = tokens[i + 1];
+      if (next && !next.startsWith('-')) {
+        options[k] = next;
+        i += 1;
+      } else {
+        options[k] = true;
+      }
+      continue;
+    }
+
+    if (token.startsWith('-')) {
+      const shortFlags = token.replace(/^-/, '').split('');
+      for (const flag of shortFlags) {
+        if (flag === 'f') options.force = true;
+        if (flag === 'd') options['dry-run'] = true;
+        if (flag === 'h') options.help = true;
+        if (flag === 'j') options.json = true;
+        if (flag === 'v') options.version = true;
+      }
+      continue;
+    }
+
+    if (command === 'help') {
+      command = token;
+    } else {
+      args.push(token);
+    }
+  }
+
+  return { command, args, options };
+}
+
+module.exports = {
+  parseArgv
+};

package/src/prompt-tool.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const SUPPORTED_PROMPT_TOOLS = new Set(['codex', 'claude', 'gemini', 'opencode']);
+
+function resolvePromptTool(value) {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
+
+  if (SUPPORTED_PROMPT_TOOLS.has(normalized)) {
+    return normalized;
+  }
+
+  return 'codex';
+}
+
+module.exports = {
+  SUPPORTED_PROMPT_TOOLS,
+  resolvePromptTool
+};