kasy-cli 1.2.1

package/lib/commands/run.js

@@ -0,0 +1,75 @@
+const { spawn } = require('node:child_process');
+const path = require('node:path');
+const fs = require('fs-extra');
+const kleur = require('kleur');
+const { createTranslator, detectDefaultLanguage } = require('../utils/i18n');
+
+/**
+ * Read dart-define args from .vscode/launch.json.
+ * Returns the args array from the matching config (dev or prod).
+ */
+async function readLaunchArgs(projectDir, useProd) {
+  const launchPath = path.join(projectDir, '.vscode', 'launch.json');
+  if (!(await fs.pathExists(launchPath))) return [];
+  try {
+    const launch = await fs.readJson(launchPath);
+    const configs = launch.configurations || [];
+    const keyword = useProd ? 'prod' : 'dev';
+    const found = configs.find((c) => c.name?.toLowerCase().includes(keyword));
+    if (!found && useProd && configs[0]) {
+      console.warn(kleur.yellow(`  ⚠  No "${keyword}" config found in launch.json — using "${configs[0].name}" instead`));
+    }
+    const config = found || configs[0];
+    return Array.isArray(config?.args) ? config.args : [];
+  } catch {
+    return [];
+  }
+}
+
+async function runRun(directory, options = {}) {
+  const t = createTranslator(options.language || detectDefaultLanguage());
+  const projectDir = path.resolve(directory || '.');
+
+  if (!(await fs.pathExists(path.join(projectDir, 'pubspec.yaml')))) {
+    throw new Error(t('run.error.notFlutterProject'));
+  }
+
+  // Resolve device flag
+  const deviceArgs = [];
+  if (options.web) {
+    deviceArgs.push('-d', 'chrome');
+  } else if (options.ios) {
+    deviceArgs.push('-d', 'ios');
+  } else if (options.android) {
+    deviceArgs.push('-d', 'android');
+  } else if (options.device) {
+    deviceArgs.push('-d', options.device);
+  }
+
+  // Read dart-defines from .vscode/launch.json (skip if --no-defines)
+  const dartDefines = options.noDefines
+    ? []
+    : await readLaunchArgs(projectDir, options.prod);
+
+  const args = ['run', ...deviceArgs, ...dartDefines];
+
+  console.log(kleur.bold(`\n${t('run.launching')}`));
+  console.log(kleur.dim(`  flutter ${args.join(' ')}\n`));
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn('flutter', args, { cwd: projectDir, stdio: 'inherit' });
+    proc.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`flutter run exited with code ${code}`));
+    });
+    proc.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        reject(new Error(t('run.error.flutterNotFound')));
+      } else {
+        reject(err);
+      }
+    });
+  });
+}
+
+module.exports = { runRun };

package/lib/commands/update.js

@@ -0,0 +1,382 @@
+'use strict';
+
+const { exec } = require('node:child_process');
+const { promisify } = require('node:util');
+const path = require('node:path');
+const fs = require('fs-extra');
+const pkg = require('../../package.json');
+const kleur = require('kleur');
+const prompts = require('prompts');
+const oraPackage = require('ora');
+const { createTranslator, detectDefaultLanguage } = require('../utils/i18n');
+const {
+  AVAILABLE_FEATURES,
+  BASE_COMPONENT_FILES,
+  CORE_SOURCE_DIR,
+  FEATURES_PATCH_DIR,
+  normalizeFeature,
+} = require('../scaffold/catalog');
+const { applyPatch } = require('../scaffold/engine');
+const { buildTokens } = require('../scaffold/backends/firebase/tokens');
+const { localizeReleaseDocs } = require('../scaffold/shared/generator-utils');
+
+const execAsync = promisify(exec);
+const ora = oraPackage.default || oraPackage;
+
+const CHANGELOG_PATH = path.join(__dirname, '..', 'scaffold', 'CHANGELOG.json');
+
+const NEEDS_BUILD_RUNNER = [
+  'revenuecat', 'analytics', 'sentry', 'onboarding', 'llm_chat', 'feedback',
+];
+const COMPONENTS_UPDATE_TARGET = 'components';
+const IOS_RELEASE_UPDATE_TARGET = 'ios-release';
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function isNewer(a, b) {
+  const parse = (v) => String(v || '0.0.0').replace(/^v/, '').split('.').map(Number);
+  const [aMaj, aMin, aPat] = parse(a);
+  const [bMaj, bMin, bPat] = parse(b);
+  if (aMaj !== bMaj) return aMaj > bMaj;
+  if (aMin !== bMin) return aMin > bMin;
+  return aPat > bPat;
+}
+
+/**
+ * Collect changelog entries newer than `fromVersion` that affect the given modules.
+ * Returns { module: ['v1.2.0: description', ...] }
+ */
+function getChangesSince(changelog, fromVersion, modules) {
+  const changes = {};
+  for (const [version, entry] of Object.entries(changelog)) {
+    if (!isNewer(version, fromVersion || '0.0.0')) continue;
+    for (const [mod, description] of Object.entries(entry.modules || {})) {
+      if (modules.includes(mod)) {
+        if (!changes[mod]) changes[mod] = [];
+        changes[mod].push({ version, description });
+      }
+    }
+  }
+  return changes;
+}
+
+function normalizeUpdateTarget(value) {
+  if (!value) {
+    return null;
+  }
+  const normalized = String(value).trim().toLowerCase().replace(/[-\s]/g, '_');
+  const componentAliases = new Set([
+    'component',
+    'components',
+    'base_component',
+    'base_components',
+    'uikit',
+    'ui_kit',
+  ]);
+  if (componentAliases.has(normalized)) {
+    return COMPONENTS_UPDATE_TARGET;
+  }
+  const iosAliases = new Set(['ios_release', 'iosrelease']);
+  if (iosAliases.has(normalized) || normalized === 'ios-release') {
+    return IOS_RELEASE_UPDATE_TARGET;
+  }
+  return null;
+}
+
+async function applyBaseComponents(projectDir) {
+  let filesApplied = 0;
+  for (const relativePath of BASE_COMPONENT_FILES) {
+    const sourcePath = path.join(CORE_SOURCE_DIR, relativePath);
+    if (!(await fs.pathExists(sourcePath))) {
+      continue;
+    }
+    const destinationPath = path.join(projectDir, relativePath);
+    await fs.ensureDir(path.dirname(destinationPath));
+    await fs.copy(sourcePath, destinationPath);
+    filesApplied += 1;
+  }
+  return filesApplied;
+}
+
+/** Same detection logic used by add.js and remove.js. */
+async function getActiveModules(kitSetup, projectDir) {
+  const modules = [];
+  if (kitSetup.useSentry) modules.push('sentry');
+  if (kitSetup.analyticsProvider === 'mixpanel') modules.push('analytics');
+  if (kitSetup.withFacebookPixel) modules.push('facebook');
+  if (kitSetup.subscriptionModule) modules.push('revenuecat');
+  if (kitSetup.withOnboarding) modules.push('onboarding');
+  if (kitSetup.webCompat) modules.push('web');
+  if (kitSetup.feedbackModule) modules.push('feedback');
+
+  const featuresPath = path.join(projectDir, 'lib', 'core', 'config', 'features.dart');
+  if (await fs.pathExists(featuresPath)) {
+    const content = await fs.readFile(featuresPath, 'utf8');
+    if (/const bool withLlmChat\s*=\s*true/.test(content)) modules.push('llm_chat');
+  }
+  if (await fs.pathExists(path.join(projectDir, '.github', 'workflows'))) modules.push('ci');
+  const pubspecPath = path.join(projectDir, 'pubspec.yaml');
+  if (await fs.pathExists(pubspecPath)) {
+    const pubspec = await fs.readFile(pubspecPath, 'utf8');
+    if (/^\s*home_widget\s*:/m.test(pubspec)) modules.push('widget');
+  }
+  return modules;
+}
+
+// ── Main command ─────────────────────────────────────────────────────────────
+
+async function runUpdate(module, options = {}) {
+  const t = createTranslator(options.language || detectDefaultLanguage());
+  const projectDir = path.resolve(options.directory || '.');
+
+  // 1. Must be inside a kasy project
+  const kitSetupPath = path.join(projectDir, 'kit_setup.json');
+  if (!(await fs.pathExists(kitSetupPath))) {
+    throw new Error(t('update.error.noProject'));
+  }
+
+  const kitSetup = await fs.readJson(kitSetupPath);
+  const projectVersion = kitSetup.cliVersion || null;
+  const currentVersion = pkg.version;
+
+  // 2. Load changelog
+  let changelog = {};
+  if (await fs.pathExists(CHANGELOG_PATH)) {
+    changelog = await fs.readJson(CHANGELOG_PATH);
+  }
+
+  // 3. Detect active modules
+  const activeModules = await getActiveModules(kitSetup, projectDir);
+
+  // ── Mode A: update a specific module ────────────────────────────────────────
+  if (module) {
+    const normalizedTarget = normalizeUpdateTarget(module);
+    if (normalizedTarget === COMPONENTS_UPDATE_TARGET) {
+      if (!options.yes) {
+        console.log(kleur.yellow(`\n  ⚠  ${t('update.warn.commitComponents')}\n`));
+        const { confirmed } = await prompts(
+          {
+            type: 'confirm',
+            name: 'confirmed',
+            message: t('update.confirmComponents'),
+            initial: false,
+          },
+          { onCancel: () => { throw new Error(t('update.cancelled')); } }
+        );
+        if (!confirmed) {
+          console.log(kleur.dim(`\n${t('update.cancelled')}\n`));
+          return;
+        }
+      }
+
+      console.log('');
+      const spinner = ora(t('update.applyingComponents')).start();
+      try {
+        const filesApplied = await applyBaseComponents(projectDir);
+        if (filesApplied === 0) {
+          spinner.warn(t('update.noComponentFiles'));
+          return;
+        }
+        spinner.succeed(t('update.appliedComponents', { count: filesApplied }));
+      } catch (err) {
+        spinner.fail(t('update.applyComponentsFailed'));
+        throw err;
+      }
+
+      {
+        const spinnerPubGet = ora(t('update.pubGet')).start();
+        try {
+          await execAsync('flutter pub get', { cwd: projectDir, timeout: 300_000 });
+          spinnerPubGet.succeed(t('update.pubGetDone'));
+        } catch {
+          spinnerPubGet.warn(t('update.pubGetFailed'));
+        }
+      }
+
+      kitSetup.cliVersion = currentVersion;
+      await fs.outputFile(kitSetupPath, JSON.stringify(kitSetup, null, 2) + '\n', 'utf8');
+      console.log(kleur.green(`\n✓ ${t('update.componentsSuccess')}\n`));
+      return;
+    }
+
+    if (normalizedTarget === IOS_RELEASE_UPDATE_TARGET) {
+      const patchDir = path.join(FEATURES_PATCH_DIR, 'ios-release');
+      if (!(await fs.pathExists(patchDir))) {
+        throw new Error(t('update.error.noIosReleasePatch'));
+      }
+      if (!options.yes) {
+        console.log(kleur.yellow(`\n  ⚠  ${t('update.warn.commit', { module: IOS_RELEASE_UPDATE_TARGET })}\n`));
+        const { confirmed } = await prompts(
+          {
+            type: 'confirm',
+            name: 'confirmed',
+            message: t('update.confirm', { module: IOS_RELEASE_UPDATE_TARGET }),
+            initial: false,
+          },
+          { onCancel: () => { throw new Error(t('update.cancelled')); } }
+        );
+        if (!confirmed) {
+          console.log(kleur.dim(`\n${t('update.cancelled')}\n`));
+          return;
+        }
+      }
+      console.log('');
+      const spinner = ora(t('update.applying', { module: IOS_RELEASE_UPDATE_TARGET })).start();
+      try {
+        const { tokens, pathReplacements } = buildTokens({
+          appName: kitSetup.appName,
+          bundleId: kitSetup.bundleId,
+        });
+        await applyPatch(patchDir, projectDir, tokens, pathReplacements);
+        await localizeReleaseDocs(projectDir, options.language || detectDefaultLanguage());
+        spinner.succeed(t('update.iosRelease.success'));
+      } catch (err) {
+        spinner.fail(t('update.applyFailed', { module: IOS_RELEASE_UPDATE_TARGET }));
+        throw err;
+      }
+      kitSetup.cliVersion = currentVersion;
+      await fs.outputFile(kitSetupPath, JSON.stringify(kitSetup, null, 2) + '\n', 'utf8');
+      console.log('');
+      return;
+    }
+
+    const normalized = normalizeFeature(module);
+    if (!normalized) {
+      throw new Error(
+        t('update.error.unknownTarget', {
+          module,
+          list: [...AVAILABLE_FEATURES, COMPONENTS_UPDATE_TARGET, IOS_RELEASE_UPDATE_TARGET].join(', '),
+        })
+      );
+    }
+    if (!activeModules.includes(normalized)) {
+      console.log(kleur.yellow(`\n${t('update.error.notActive', { module: normalized })}\n`));
+      return;
+    }
+
+    const patchDir = path.join(FEATURES_PATCH_DIR, normalized);
+    if (!(await fs.pathExists(patchDir))) {
+      console.log(kleur.dim(`\n  ${t('update.noPatch', { module: normalized })}\n`));
+      return;
+    }
+
+    // Warn and confirm
+    if (!options.yes) {
+      console.log(kleur.yellow(`\n  ⚠  ${t('update.warn.commit', { module: normalized })}\n`));
+      const { confirmed } = await prompts(
+        {
+          type: 'confirm',
+          name: 'confirmed',
+          message: t('update.confirm', { module: normalized }),
+          initial: false,
+        },
+        { onCancel: () => { throw new Error(t('update.cancelled')); } }
+      );
+      if (!confirmed) {
+        console.log(kleur.dim(`\n${t('update.cancelled')}\n`));
+        return;
+      }
+    }
+
+    console.log('');
+
+    // Re-apply patch
+    {
+      const spinner = ora(t('update.applying', { module: normalized })).start();
+      try {
+        const { tokens, pathReplacements } = buildTokens({
+          appName: kitSetup.appName,
+          bundleId: kitSetup.bundleId,
+        });
+        await applyPatch(patchDir, projectDir, tokens, pathReplacements);
+        spinner.succeed(t('update.applied', { module: normalized }));
+      } catch (err) {
+        spinner.fail(t('update.applyFailed', { module: normalized }));
+        throw err;
+      }
+    }
+
+    // flutter pub get
+    {
+      const spinner = ora(t('update.pubGet')).start();
+      try {
+        await execAsync('flutter pub get', { cwd: projectDir, timeout: 300_000 });
+        spinner.succeed(t('update.pubGetDone'));
+      } catch {
+        spinner.warn(t('update.pubGetFailed'));
+      }
+    }
+
+    // build_runner (only for modules that generate code)
+    if (NEEDS_BUILD_RUNNER.includes(normalized)) {
+      const spinner = ora(t('update.buildRunner')).start();
+      try {
+        await execAsync(
+          'dart run build_runner build --delete-conflicting-outputs',
+          { cwd: projectDir, timeout: 600_000 }
+        );
+        spinner.succeed(t('update.buildRunnerDone'));
+      } catch {
+        spinner.warn(t('update.buildRunnerFailed'));
+      }
+    }
+
+    // Update cliVersion
+    kitSetup.cliVersion = currentVersion;
+    await fs.outputFile(kitSetupPath, JSON.stringify(kitSetup, null, 2) + '\n', 'utf8');
+
+    console.log(kleur.green(`\n✓ ${t('update.success', { module: normalized })}\n`));
+    return;
+  }
+
+  // ── Mode B: show status ──────────────────────────────────────────────────────
+  const alreadyUpToDate = projectVersion && !isNewer(currentVersion, projectVersion);
+  const changes = getChangesSince(changelog, projectVersion, activeModules);
+
+  // Modules in this project that have patch dirs (can be re-applied)
+  const patchableModules = [];
+  for (const m of activeModules) {
+    if (await fs.pathExists(path.join(FEATURES_PATCH_DIR, m))) {
+      patchableModules.push(m);
+    }
+  }
+
+  if (alreadyUpToDate && Object.keys(changes).length === 0) {
+    console.log(kleur.green(`\n✓ ${t('update.alreadyUpToDate', { version: currentVersion })}\n`));
+    return;
+  }
+
+  // Header
+  const fromLabel = projectVersion || '?';
+  console.log(`\n${t('update.status', { from: fromLabel, to: currentVersion })}\n`);
+
+  if (!projectVersion) {
+    console.log(kleur.dim(`  ${t('update.noVersion')}\n`));
+  }
+
+  // Changelog per module
+  if (Object.keys(changes).length > 0) {
+    console.log(kleur.bold(t('update.changesTitle')));
+    for (const [mod, entries] of Object.entries(changes)) {
+      console.log(kleur.cyan(`  ${mod}`));
+      for (const { version, description } of entries) {
+        console.log(kleur.dim(`    v${version}: ${description}`));
+      }
+    }
+    console.log('');
+  }
+
+  // Instructions
+  if (patchableModules.length > 0) {
+    console.log(t('update.howToUpdate'));
+    for (const m of patchableModules) {
+      console.log(kleur.cyan(`  kasy update ${m}`));
+    }
+    console.log('');
+  }
+  console.log(t('update.howToUpdateComponents'));
+  console.log(kleur.cyan(`  kasy update ${COMPONENTS_UPDATE_TARGET}`));
+  console.log('');
+}
+
+module.exports = { runUpdate };

package/lib/commands/validate.js

@@ -0,0 +1,131 @@
+const path = require('node:path');
+const { promisify } = require('node:util');
+const { execFile } = require('node:child_process');
+const kleur = require('kleur');
+const { createTranslator, detectDefaultLanguage } = require('../utils/i18n');
+const { pathExists } = require('../utils/fs');
+
+const execFileAsync = promisify(execFile);
+const REPO_ROOT = path.resolve(__dirname, '../../..');
+
+const VALIDATION_MATRIX = [
+  {
+    id: 'firebase_widget',
+    backend: 'firebase',
+    features: ['widget'],
+    projectPath: path.join(REPO_ROOT, 'kasy_firebase_base')
+  },
+  {
+    id: 'supabase_widget',
+    backend: 'supabase',
+    features: ['widget'],
+    projectPath: path.join(REPO_ROOT, 'kasy_supabase_base')
+  },
+  {
+    id: 'api_web_ci',
+    backend: 'api',
+    features: ['web', 'ci'],
+    projectPath: path.join(REPO_ROOT, 'kasy_api_base')
+  }
+];
+
+async function runCommand(cmd, args, cwd) {
+  await execFileAsync(cmd, args, { cwd, env: process.env });
+}
+
+function buildCommandsForPlatform(analyzeOnly) {
+  const commands = [['flutter', ['analyze']]];
+  if (analyzeOnly) {
+    return commands;
+  }
+
+  commands.push(['flutter', ['build', 'apk', '--debug', '--no-pub']]);
+
+  if (process.platform === 'darwin') {
+    commands.push(['flutter', ['build', 'ios', '--simulator', '--no-codesign', '--no-pub']]);
+  }
+
+  return commands;
+}
+
+async function runValidate({ language, analyzeOnly = false } = {}) {
+  const t = createTranslator(language || detectDefaultLanguage());
+
+  const anyExists = await Promise.any(
+    VALIDATION_MATRIX.map(async (c) => {
+      if (!(await pathExists(c.projectPath))) throw new Error();
+    })
+  ).then(() => true).catch(() => false);
+
+  if (!anyExists) {
+    console.log(kleur.yellow('\n⚠ kasy validate is only available in the Kasy development environment.'));
+    console.log(kleur.gray('  Generate test projects with `kasy new` first, then run this command.\n'));
+    return;
+  }
+
+  console.log(kleur.bold(`\n${t('validate.title')}\n`));
+
+  const commands = buildCommandsForPlatform(analyzeOnly);
+  const failures = [];
+
+  for (const combo of VALIDATION_MATRIX) {
+    const label = `${combo.backend} + ${combo.features.join('+')}`;
+    const exists = await pathExists(combo.projectPath);
+
+    if (!exists) {
+      const projectName = path.basename(combo.projectPath);
+      failures.push({ combo: combo.id, reason: `${t('validate.projectNotFound')}: ${combo.projectPath}` });
+      console.log(kleur.red(`✗ ${label}`));
+      console.log(kleur.gray(`  ${combo.projectPath}`));
+      console.log(
+        kleur.yellow(
+          `  ⚠ Projeto base não encontrado. Gere-o antes de validar:\n` +
+          `    kasy new ${projectName} --backend ${combo.backend}\n` +
+          `  O projeto deve ser gerado uma vez e mantido localmente para CI.`
+        )
+      );
+      continue;
+    }
+
+    console.log(kleur.cyan(`• ${label}`));
+    console.log(kleur.gray(`  ${combo.projectPath}`));
+
+    let comboFailed = false;
+    for (const [cmd, args] of commands) {
+      const printable = `${cmd} ${args.join(' ')}`;
+      process.stdout.write(kleur.gray(`  - ${printable} ... `));
+
+      try {
+        await runCommand(cmd, args, combo.projectPath);
+        process.stdout.write(`${kleur.green(t('validate.ok'))}\n`);
+      } catch (error) {
+        comboFailed = true;
+        failures.push({
+          combo: combo.id,
+          reason: `${printable} ${t('validate.fail')}`
+        });
+        process.stdout.write(`${kleur.red(t('validate.fail'))}\n`);
+        break;
+      }
+    }
+
+    if (!comboFailed) {
+      console.log(kleur.green(`  ✓ ${combo.id} ${t('validate.passed')}`));
+    }
+  }
+
+  if (failures.length > 0) {
+    console.log(kleur.red(`\n${t('validate.failed')}`));
+    failures.forEach((failure) => {
+      console.log(kleur.red(`- ${failure.combo}: ${failure.reason}`));
+    });
+    throw new Error(t('validate.error'));
+  }
+
+  console.log(kleur.green(`\n${t('validate.success')}`));
+}
+
+module.exports = {
+  runValidate,
+  VALIDATION_MATRIX
+};

package/lib/scaffold/CHANGELOG.json

@@ -0,0 +1,6 @@
+{
+  "1.0.0": {
+    "notes": "Initial release",
+    "features": {}
+  }
+}