wizz-method 2.16.0 → 2.17.1

package/tools/installer/core/subagent-models.js

@@ -0,0 +1,112 @@
+// Modelo dos subagentes resolvido na instalação (2026-10-05).
+//
+// O spec.yaml pina um modelo por tier e plataforma. No Claude Code isso é um
+// apelido (haiku/sonnet/opus/fable) que o próprio Claude Code aponta para a
+// versão mais nova, então o arquivo passa intacto. O Codex não tem apelido de
+// "mais novo": aqui o installer lê o cache de modelos do Codex desta máquina
+// (~/.codex/models_cache.json) e troca o modelo pinado pelo mais novo da mesma
+// classe (barato / do dia a dia / fronteira). Qualquer dúvida mantém o pinado:
+// sem cache, cache mais velho que o spec (o pinado nem aparece nele), esforço
+// que o modelo novo não suporta, ou JSON em formato inesperado.
+//
+// OpenCode e Gemini seguem pinados: falta uma fonte local confiável da lista
+// de modelos deles.
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const CLASS_PATTERNS = {
+  fast: /\b(fast|affordable|efficient|lightweight|cheap|mini|nano)\b/i,
+  frontier: /\b(frontier|most capable|most demanding|most intelligent)\b/i,
+};
+const OUTDATED = /\b(older|legacy|deprecated)\b/i;
+
+function defaultCodexCachePath() {
+  return process.env.CODEX_MODELS_CACHE || path.join(os.homedir(), '.codex', 'models_cache.json');
+}
+
+function loadCodexCache(cachePath = defaultCodexCachePath()) {
+  try {
+    return JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+// Classe pela descrição; um modelo antigo ("Older fast and efficient model")
+// ainda casa a classe certa porque o padrão ignora o "Older".
+function classOf(entry) {
+  const text = `${entry.slug} ${entry.description || ''}`;
+  if (CLASS_PATTERNS.frontier.test(text)) return 'frontier';
+  if (CLASS_PATTERNS.fast.test(text)) return 'fast';
+  return 'workhorse';
+}
+
+function isCurrent(entry) {
+  return entry.visibility === 'list' && !entry.upgrade && !OUTDATED.test(entry.description || '');
+}
+
+function supportsEffort(entry, effort) {
+  if (!effort) return true;
+  const levels = Array.isArray(entry.supported_reasoning_levels) ? entry.supported_reasoning_levels : [];
+  return levels.some((level) => level && level.effort === effort);
+}
+
+/**
+ * Modelo Codex mais novo da mesma classe do pinado, ou o próprio pinado.
+ * @param {string} pinned - modelo do spec
+ * @param {string|undefined} effort - model_reasoning_effort do arquivo
+ * @param {Object|null} cache - conteúdo de models_cache.json
+ */
+function resolveCodexModel(pinned, effort, cache) {
+  const models = cache && Array.isArray(cache.models) ? cache.models.filter((m) => m && typeof m.slug === 'string') : null;
+  if (!models) return pinned;
+  const pinnedEntry = models.find((m) => m.slug === pinned);
+  // O pinado fora do cache = cache mais velho que o spec: nunca rebaixar.
+  if (!pinnedEntry) return pinned;
+  const wanted = classOf(pinnedEntry);
+  const newest = models
+    .filter((m) => isCurrent(m) && classOf(m) === wanted)
+    .sort((a, b) => (a.priority ?? Infinity) - (b.priority ?? Infinity))[0];
+  if (!newest || !supportsEffort(newest, effort)) return pinned;
+  return newest.slug;
+}
+
+function readModel(content) {
+  const match = content.match(/^model = "([^"]+)"$/m) || content.match(/^model: (\S+)$/m);
+  return match ? match[1] : null;
+}
+
+function replaceModel(content, from, to) {
+  return from && to && from !== to ? content.split(from).join(to) : content;
+}
+
+/**
+ * Conteúdo do subagente com o modelo resolvido para esta máquina.
+ * @param {string} content - arquivo gerado a partir do spec
+ * @param {string|undefined} platform - agents_source_subdir (codex, gemini...)
+ * @param {Object} [opts] - codexCache (objeto) ou codexCachePath
+ */
+function renderSubagent(content, platform, opts = {}) {
+  if (platform !== 'codex') return content;
+  const pinned = readModel(content);
+  if (!pinned) return content;
+  const effort = (content.match(/^model_reasoning_effort = "([^"]+)"$/m) || [])[1];
+  const cache = opts.codexCache === undefined ? loadCodexCache(opts.codexCachePath) : opts.codexCache;
+  return replaceModel(content, pinned, resolveCodexModel(pinned, effort, cache));
+}
+
+/**
+ * Dois arquivos iguais a menos do modelo: um arquivo instalado com outro
+ * modelo resolvido continua sendo do Wizz (não precisa de backup).
+ */
+function sameExceptModel(a, b) {
+  if (a === b) return true;
+  const modelA = readModel(a);
+  const modelB = readModel(b);
+  if (!modelA || !modelB) return false;
+  return a.split(modelA).join('<wizz-model>') === b.split(modelB).join('<wizz-model>');
+}
+
+module.exports = { renderSubagent, resolveCodexModel, sameExceptModel, loadCodexCache };

package/tools/installer/ide/_config-driven.js

@@ -6,6 +6,7 @@ const prompts = require('../prompts');
 const { loadCsvCached } = require('../core/yaml-cache');
 const { WIZZ_FOLDER_NAME } = require('./shared/path-utils');
 const { findExistingWizzDir } = require('../core/wizz-dir');
+const { renderSubagent, sameExceptModel } = require('../core/subagent-models');
 const { getInstalledCanonicalIds, isWizzOwnedEntry } = require('./shared/installed-skills');
 
 // Reserved OpenCode slash commands. A skill whose canonicalId collides with
@@ -567,7 +568,8 @@ class ConfigDrivenIdeSetup {
           }
           const existing = await fs.readFile(targetFile, 'utf8');
           const source = await fs.readFile(sourcePath, 'utf8');
-          if (existing !== source) {
+          // Same file with another resolved model is still Wizz-generated.
+          if (!sameExceptModel(existing, source)) {
             const backupPath = await this._backupSubagentFile(targetFile, options, report);
             if (!backupPath) {
               report.preserved++;
@@ -576,7 +578,10 @@ class ConfigDrivenIdeSetup {
             report.backups++;
           }
         }
-        await fs.copy(sourcePath, targetFile, { overwrite: true });
+        const rendered = renderSubagent(await fs.readFile(sourcePath, 'utf8'), config.agents_source_subdir, {
+          codexCachePath: options.codexModelsCachePath,
+        });
+        await fs.writeFile(targetFile, rendered);
         count++;
         report.installed++;
       } catch (error) {
@@ -930,7 +935,7 @@ class ConfigDrivenIdeSetup {
       // Exact source equality is the only proof that a source-backed file is
       // unchanged. Without a matching source, both current and legacy tiers
       // may contain customizations and must be backed up before removal.
-      const generated = sourceContent !== undefined && content === sourceContent;
+      const generated = sourceContent !== undefined && sameExceptModel(content, sourceContent);
       if (!generated) {
         const backupPath = await this._backupSubagentFile(filePath, options, report);
         if (!backupPath) {