@jaimevalasek/aioson 1.3.0

package/src/commands/config.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+
+const CONFIG_DIR = path.join(os.homedir(), '.aioson');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+async function readConfig() {
+  try {
+    const raw = await fs.readFile(CONFIG_FILE, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+async function writeConfig(data) {
+  await fs.mkdir(CONFIG_DIR, { recursive: true });
+  await fs.writeFile(CONFIG_FILE, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+}
+
+async function runConfig({ args, options, logger, t }) {
+  const subcommand = args[0];
+
+  if (subcommand === 'set') {
+    const pair = args[1];
+    if (!pair || !pair.includes('=')) {
+      logger.error(t('config.usage_error'));
+      return { ok: false, error: { code: 'usage_error' } };
+    }
+    const eqIdx = pair.indexOf('=');
+    const key = pair.slice(0, eqIdx).trim();
+    const value = pair.slice(eqIdx + 1).trim();
+    if (!key) {
+      logger.error(t('config.usage_error'));
+      return { ok: false, error: { code: 'usage_error' } };
+    }
+    const config = await readConfig();
+    config[key] = value;
+    await writeConfig(config);
+    logger.log(t('config.set_ok', { key, path: CONFIG_FILE }));
+    return { ok: true, key, path: CONFIG_FILE };
+  }
+
+  if (subcommand === 'get') {
+    const key = args[1];
+    if (!key) {
+      logger.error(t('config.usage_error'));
+      return { ok: false, error: { code: 'usage_error' } };
+    }
+    const config = await readConfig();
+    if (!Object.prototype.hasOwnProperty.call(config, key)) {
+      logger.log(t('config.key_not_found', { key }));
+      return { ok: true, key, value: null };
+    }
+    logger.log(t('config.get_line', { key, value: config[key] }));
+    return { ok: true, key, value: config[key] };
+  }
+
+  if (!subcommand || subcommand === 'show') {
+    const config = await readConfig();
+    const keys = Object.keys(config);
+    logger.log(t('config.show_header', { path: CONFIG_FILE }));
+    if (keys.length === 0) {
+      logger.log(t('config.show_empty'));
+    } else {
+      for (const key of keys) {
+        const raw = String(config[key]);
+        const masked = key.toLowerCase().includes('key') || key.toLowerCase().includes('secret')
+          ? `${raw.slice(0, 6)}${'*'.repeat(Math.max(0, raw.length - 6))}`
+          : raw;
+        logger.log(t('config.show_line', { key, value: masked }));
+      }
+    }
+    return { ok: true, config };
+  }
+
+  logger.error(t('config.usage_error'));
+  return { ok: false, error: { code: 'usage_error' } };
+}
+
+module.exports = {
+  runConfig,
+  readConfig,
+  writeConfig,
+  CONFIG_DIR,
+  CONFIG_FILE
+};

package/src/commands/context-validate.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const path = require('node:path');
+const { validateProjectContextFile } = require('../context');
+const { localizeContextParseReason } = require('../context-parse-reason');
+
+async function runContextValidate({ args, options = {}, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const jsonMode = Boolean(options.json);
+  const result = await validateProjectContextFile(targetDir);
+
+  const base = {
+    targetDir
+  };
+
+  if (!result.exists) {
+    const output = {
+      ok: false,
+      reason: 'missing_file',
+      ...base,
+      ...result
+    };
+    if (jsonMode) {
+      return output;
+    }
+    logger.log(t('context_validate.missing_file', { path: result.filePath }));
+    logger.log(t('context_validate.hint_setup'));
+    return output;
+  }
+
+  if (!result.parsed) {
+    const output = {
+      ok: false,
+      reason: 'invalid_frontmatter',
+      ...base,
+      ...result
+    };
+    if (jsonMode) {
+      return output;
+    }
+    logger.log(t('context_validate.invalid_frontmatter'));
+    logger.log(t('context_validate.file_path', { path: result.filePath }));
+    logger.log(
+      t('context_validate.parse_reason', {
+        reason: localizeContextParseReason(result.parseError, t)
+      })
+    );
+    logger.log(t('context_validate.hint_fix_frontmatter'));
+    return output;
+  }
+
+  if (!result.valid) {
+    const output = {
+      ok: false,
+      reason: 'invalid_fields',
+      ...base,
+      ...result
+    };
+    if (jsonMode) {
+      return output;
+    }
+    logger.log(t('context_validate.invalid_fields'));
+    logger.log(t('context_validate.file_path', { path: result.filePath }));
+    for (const issue of result.issues) {
+      logger.log(
+        t('context_validate.issue_line', {
+          issue: t(issue.key, issue.params || {})
+        })
+      );
+    }
+    return output;
+  }
+
+  const output = {
+    ok: true,
+    reason: 'valid',
+    ...base,
+    ...result
+  };
+  if (jsonMode) {
+    return output;
+  }
+  logger.log(t('context_validate.valid'));
+  logger.log(t('context_validate.file_path', { path: result.filePath }));
+  return output;
+}
+
+module.exports = {
+  runContextValidate,
+  localizeParseReason: localizeContextParseReason
+};

package/src/commands/doctor.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const path = require('node:path');
+const { runDoctor, applyDoctorFixes } = require('../doctor');
+
+function printDoctorChecks(report, logger, t) {
+  for (const check of report.checks) {
+    const icon = check.ok ? t('doctor.ok') : t('doctor.fail');
+    logger.log(
+      t('doctor.check_line', {
+        icon,
+        message: t(check.key, check.params)
+      })
+    );
+    if (!check.ok && check.hintKey) {
+      logger.log(
+        t('doctor.hint_line', {
+          hint: t(check.hintKey, check.hintParams || check.params)
+        })
+      );
+    }
+  }
+}
+
+function printFixAction(action, logger, t, dryRun) {
+  logger.log(
+    t('doctor.fix_action_line', {
+      action: t(`doctor.fix_action_${action.id}`)
+    })
+  );
+  if (action.skipped) {
+    logger.log(
+      t('doctor.detail_line', {
+        text: t('doctor.fix_not_applicable')
+      })
+    );
+    return;
+  }
+  logger.log(
+    t('doctor.detail_line', {
+      text: t('doctor.fix_target_count', { count: action.missingCount || action.count || 0 })
+    })
+  );
+  logger.log(
+    t('doctor.detail_line', {
+      text: t(dryRun ? 'doctor.fix_planned_count' : 'doctor.fix_applied_count', {
+        count: action.count || 0
+      })
+    })
+  );
+  if (action.locale) {
+    logger.log(
+      t('doctor.detail_line', {
+        text: t('doctor.fix_locale', { locale: action.locale })
+      })
+    );
+  }
+}
+
+async function runDoctorCommand({ args, options = {}, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const fix = Boolean(options.fix);
+  const dryRun = Boolean(options['dry-run']);
+  const jsonMode = Boolean(options.json);
+
+  let report = await runDoctor(targetDir);
+  let fixResult = null;
+
+  if (fix) {
+    if (!jsonMode) {
+      logger.log(dryRun ? t('doctor.fix_start_dry_run') : t('doctor.fix_start'));
+    }
+    fixResult = await applyDoctorFixes(targetDir, report, { dryRun });
+    if (!jsonMode) {
+      for (const action of fixResult.actions) {
+        printFixAction(action, logger, t, dryRun);
+      }
+
+      logger.log(
+        dryRun
+          ? t('doctor.fix_summary_dry_run', { count: fixResult.changedCount })
+          : t('doctor.fix_summary', { count: fixResult.changedCount })
+      );
+      logger.log('');
+    }
+    report = await runDoctor(targetDir);
+  }
+
+  const output = {
+    ok: report.ok,
+    targetDir,
+    fix: {
+      enabled: fix,
+      dryRun,
+      ...(fixResult
+        ? {
+            changedCount: fixResult.changedCount,
+            actions: fixResult.actions
+          }
+        : {})
+    },
+    report
+  };
+
+  if (jsonMode) {
+    return output;
+  }
+
+  printDoctorChecks(report, logger, t);
+
+  logger.log('');
+  if (!report.ok) {
+    logger.log(t('doctor.diagnosis_fail', { count: report.failedCount }));
+  } else {
+    logger.log(t('doctor.diagnosis_ok'));
+  }
+
+  return output;
+}
+
+module.exports = {
+  runDoctorCommand
+};

package/src/commands/genome-doctor.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { loadCompatibleGenome } = require('../lib/genomes/compat');
+
+async function runGenomeDoctor({ args, options = {}, logger }) {
+  const target = args[0];
+  if (!target) {
+    throw new Error('Usage: aioson genome:doctor <file>');
+  }
+
+  const filePath = path.resolve(process.cwd(), target);
+  const raw = await fs.readFile(filePath, 'utf8');
+  const loaded = loadCompatibleGenome(raw, { filePath });
+  const result = {
+    ok: true,
+    file: filePath,
+    detectedFormat: loaded.format,
+    migrated: loaded.migrated,
+    slug: loaded.document.slug,
+    type: loaded.document.type,
+    depth: loaded.document.depth,
+    evidenceMode: loaded.document.evidenceMode
+  };
+
+  if (options.json) return result;
+
+  logger.log(`Genome file: ${filePath}`);
+  logger.log(`Format: ${result.detectedFormat}`);
+  logger.log(`Migrated internally: ${result.migrated ? 'yes' : 'no'}`);
+  logger.log(`Slug: ${result.slug}`);
+  logger.log(`Type: ${result.type}`);
+  logger.log(`Depth: ${result.depth}`);
+  logger.log(`Evidence mode: ${result.evidenceMode}`);
+  return result;
+}
+
+module.exports = {
+  runGenomeDoctor
+};

package/src/commands/genome-migrate.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { migrateGenomeDirectory, migrateGenomeFile } = require('../lib/genomes/migrate');
+
+async function runGenomeMigrate({ args, options = {}, logger }) {
+  const target = args[0];
+  if (!target) {
+    throw new Error('Usage: aioson genome:migrate <file-or-dir> [--write] [--no-backup]');
+  }
+
+  const resolvedTarget = path.resolve(process.cwd(), target);
+  const write = Boolean(options.write);
+  const backup = !Boolean(options['no-backup']);
+  const stat = await fs.stat(resolvedTarget);
+  const payload = stat.isDirectory()
+    ? await migrateGenomeDirectory(resolvedTarget, { dryRun: !write, write, backup })
+    : await migrateGenomeFile(resolvedTarget, { dryRun: !write, write, backup });
+  const result = {
+    ok: true,
+    target: resolvedTarget,
+    write,
+    dryRun: !write,
+    backup,
+    ...(stat.isDirectory()
+      ? { kind: 'directory', ...payload }
+      : { kind: 'file', ...payload })
+  };
+
+  if (options.json) return result;
+
+  logger.log(`Genome migrate target: ${resolvedTarget}`);
+  logger.log(`Mode: ${result.dryRun ? 'dry-run' : 'write'}`);
+  if (result.kind === 'directory') {
+    logger.log(`Files scanned: ${result.total}`);
+    logger.log(`Files changed: ${result.changed}`);
+  } else {
+    logger.log(`Detected format: ${result.detectedFormat}`);
+    logger.log(`Changed: ${result.changed ? 'yes' : 'no'}`);
+    if (result.backupPath) logger.log(`Backup: ${result.backupPath}`);
+  }
+
+  return result;
+}
+
+module.exports = {
+  runGenomeMigrate
+};

package/src/commands/i18n-add.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const { createLocaleScaffold } = require('../i18n/scaffold');
+
+async function runI18nAdd({ args, options, logger, t }) {
+  const requestedLocale = args[0];
+  if (!requestedLocale) {
+    throw new Error(t('i18n_add.usage_error'));
+  }
+
+  const force = Boolean(options.force);
+  const dryRun = Boolean(options['dry-run']);
+
+  let result;
+  try {
+    result = await createLocaleScaffold(requestedLocale, { force, dryRun });
+  } catch (error) {
+    if (error.code === 'INVALID_LOCALE') {
+      throw new Error(t('i18n_add.invalid_locale', { locale: requestedLocale }));
+    }
+    if (error.code === 'BASE_LOCALE') {
+      throw new Error(t('i18n_add.base_locale'));
+    }
+    if (error.code === 'LOCALE_EXISTS') {
+      throw new Error(t('i18n_add.locale_exists', { path: error.path }));
+    }
+    throw error;
+  }
+
+  if (result.dryRun) {
+    logger.log(
+      result.overwritten
+        ? t('i18n_add.dry_run_overwritten', { locale: result.locale })
+        : t('i18n_add.dry_run_created', { locale: result.locale })
+    );
+  } else {
+    logger.log(
+      result.overwritten
+        ? t('i18n_add.overwritten', { locale: result.locale })
+        : t('i18n_add.created', { locale: result.locale })
+    );
+  }
+  logger.log(t('i18n_add.file_path', { path: result.filePath }));
+  logger.log(t('i18n_add.next_steps'));
+  logger.log(t('i18n_add.step_translate'));
+  logger.log(t('i18n_add.step_try', { locale: result.locale }));
+
+  return {
+    ok: true,
+    ...result
+  };
+}
+
+module.exports = {
+  runI18nAdd
+};

package/src/commands/info.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const path = require('node:path');
+const { detectFramework } = require('../detector');
+const { detectExistingInstall } = require('../installer');
+const { getCliVersion } = require('../version');
+
+async function runInfo({ args, options = {}, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const jsonMode = Boolean(options.json);
+  const version = await getCliVersion();
+
+  const installed = await detectExistingInstall(targetDir);
+  const detection = await detectFramework(targetDir);
+
+  const result = {
+    ok: true,
+    version,
+    targetDir,
+    installed,
+    detection
+  };
+
+  if (jsonMode) {
+    return result;
+  }
+
+  logger.log(t('info.cli_version', { version }));
+  logger.log(t('info.directory', { targetDir }));
+  logger.log(t('info.installed_here', { value: installed ? t('info.yes') : t('info.no') }));
+  logger.log(t('info.framework_detected', { framework: detection.framework || t('info.none') }));
+  if (detection.evidence) {
+    logger.log(t('info.evidence', { evidence: detection.evidence }));
+  }
+
+  return result;
+}
+
+module.exports = {
+  runInfo
+};

package/src/commands/init.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { installTemplate } = require('../installer');
+const { applyAgentLocale } = require('../locales');
+const { resolvePromptTool } = require('../prompt-tool');
+
+async function directoryIsEmpty(dirPath) {
+  try {
+    const entries = await fs.readdir(dirPath);
+    return entries.length === 0;
+  } catch (error) {
+    if (error && error.code === 'ENOENT') return true;
+    throw error;
+  }
+}
+
+async function runInit({ args, options, logger, t }) {
+  const projectName = args[0];
+  if (!projectName) {
+    throw new Error(t('init.usage_error'));
+  }
+
+  const targetDir = path.resolve(process.cwd(), projectName);
+  const force = Boolean(options.force);
+  const dryRun = Boolean(options['dry-run']);
+  const requestedLanguage = options.lang || options.language;
+  const promptTool = resolvePromptTool(options.tool);
+
+  await fs.mkdir(targetDir, { recursive: true });
+
+  if (!(await directoryIsEmpty(targetDir)) && !force) {
+    throw new Error(t('init.non_empty_dir', { targetDir }));
+  }
+
+  const result = await installTemplate(targetDir, {
+    overwrite: true,
+    dryRun,
+    mode: 'init'
+  });
+
+  let localeApply = null;
+  if (requestedLanguage) {
+    localeApply = await applyAgentLocale(targetDir, requestedLanguage, { dryRun });
+    if (dryRun) {
+      logger.log(t('locale_apply.dry_run_applied', { locale: localeApply.locale }));
+    } else {
+      logger.log(t('locale_apply.applied', { locale: localeApply.locale }));
+    }
+  }
+
+  logger.log(t('init.created_at', { targetDir }));
+  logger.log(t('init.files_copied', { count: result.copied.length }));
+  if (result.skipped.length > 0) {
+    logger.log(t('init.files_skipped', { count: result.skipped.length }));
+  }
+  logger.log(t('init.next_steps'));
+  logger.log(t('init.step_cd', { projectName }));
+  logger.log(t('init.step_setup'));
+  logger.log(t('init.step_agents'));
+  logger.log(t('init.step_agent_prompt', { tool: promptTool }));
+
+  return {
+    ok: true,
+    targetDir,
+    ...result,
+    localeApply
+  };
+}
+
+module.exports = {
+  runInit,
+  directoryIsEmpty
+};

package/src/commands/install.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const path = require('node:path');
+const { detectFramework } = require('../detector');
+const { installTemplate } = require('../installer');
+const { applyAgentLocale } = require('../locales');
+const { resolvePromptTool } = require('../prompt-tool');
+
+async function runInstall({ args, options, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const force = Boolean(options.force);
+  const dryRun = Boolean(options['dry-run']);
+  const requestedLanguage = options.lang || options.language;
+  const promptTool = resolvePromptTool(options.tool);
+
+  const detection = await detectFramework(targetDir);
+  if (detection.installed) {
+    logger.log(t('install.framework_detected', {
+      framework: detection.framework,
+      evidence: detection.evidence
+    }));
+  } else {
+    logger.log(t('install.framework_not_detected'));
+  }
+
+  const result = await installTemplate(targetDir, {
+    overwrite: force,
+    dryRun,
+    mode: 'install',
+    frameworkDetection: detection.framework
+  });
+
+  let localeApply = null;
+  if (requestedLanguage) {
+    localeApply = await applyAgentLocale(targetDir, requestedLanguage, { dryRun });
+    if (dryRun) {
+      logger.log(t('locale_apply.dry_run_applied', { locale: localeApply.locale }));
+    } else {
+      logger.log(t('locale_apply.applied', { locale: localeApply.locale }));
+    }
+  }
+
+  logger.log(t('install.done_at', { targetDir }));
+  logger.log(t('install.files_copied', { count: result.copied.length }));
+  logger.log(t('install.files_skipped', { count: result.skipped.length }));
+  logger.log(t('install.next_steps'));
+  logger.log(t('install.step_setup_context'));
+  logger.log(t('install.step_agents'));
+  logger.log(t('install.step_agent_prompt', { tool: promptTool }));
+
+  if (result.isExistingProject) {
+    logger.log('');
+    logger.log(t('install.existing_project_detected', { count: result.projectFileCount }));
+    logger.log(t('install.existing_project_scan_hint'));
+  }
+
+  return {
+    ok: true,
+    targetDir,
+    detection,
+    ...result,
+    localeApply
+  };
+}
+
+module.exports = {
+  runInstall
+};

package/src/commands/locale-apply.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const path = require('node:path');
+const { applyAgentLocale, resolveAgentLocale } = require('../locales');
+const { validateProjectContextFile } = require('../context');
+
+async function runLocaleApply({ args, options, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const dryRun = Boolean(options['dry-run']);
+
+  let requestedLanguage = options.language || options.lang || '';
+  if (!requestedLanguage) {
+    const context = await validateProjectContextFile(targetDir);
+    if (context.parsed && context.data && context.data.conversation_language) {
+      requestedLanguage = context.data.conversation_language;
+    }
+  }
+
+  const locale = resolveAgentLocale(requestedLanguage || 'en');
+  const result = await applyAgentLocale(targetDir, locale, { dryRun });
+
+  logger.log(
+    dryRun
+      ? t('locale_apply.dry_run_applied', { locale: result.locale })
+      : t('locale_apply.applied', { locale: result.locale })
+  );
+  logger.log(t('locale_apply.copied_count', { count: result.copied.length }));
+
+  if (result.missing.length > 0) {
+    logger.log(t('locale_apply.missing_count', { count: result.missing.length }));
+  }
+
+  for (const item of result.copied) {
+    logger.log(
+      t('locale_apply.copy_line', {
+        source: item.source,
+        target: item.target
+      })
+    );
+  }
+
+  return {
+    ok: true,
+    targetDir,
+    ...result
+  };
+}
+
+module.exports = {
+  runLocaleApply
+};