triflux 10.61.2 → 10.63.0

package/scripts/lib/gemini-profiles.mjs

@@ -1,72 +1,64 @@
+import { copyFileSync, existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import {
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-} from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
+  FLASH_FAMILY_PROFILES,
+  modelFamilyPaths,
+  resolveModelFamilies,
+  writeModelFile,
+} from "./model-family-resolver.mjs";
 
-// 모델명 SSOT. 값은 `agy models` 가 출력하는 display name 형식이다
-// (`--model` 인자가 이 문자열을 받는다). 옛 `gemini-*-preview` ID 형식이 아님.
-// 카탈로그 확인: agy 1.1.27 `agy models` (2026-09-07). 운영 정책은 3.8 Flash 한 세대만
-// 쓰고 effort(Low/Medium/High)로 차등한다. Pro 와 이전 세대 Flash 는 기본 프로필에서 뺐다.
 const DEFAULT_GEMINI_PROFILES = {
-  model: "Gemini 3.8 Flash (Medium)",
-  profiles: {
-    flash38_low: {
-      model: "Gemini 3.8 Flash (Low)",
-      hint: "3.8 Flash (Low) — 경량·저비용",
-    },
-    flash38: {
-      model: "Gemini 3.8 Flash (Medium)",
-      hint: "3.8 Flash (Medium) — 기본, 비용·속도 균형",
-    },
-    flash38_high: {
-      model: "Gemini 3.8 Flash (High)",
-      hint: "3.8 Flash (High) — 코드/추론 강화",
-    },
-  },
+  model: FLASH_FAMILY_PROFILES.flash.model,
+  profiles: Object.fromEntries(
+    Object.entries(FLASH_FAMILY_PROFILES).map(([name, { model }]) => [
+      name,
+      { model },
+    ]),
+  ),
 };
 
+export function normalizeGeminiProfileName(name) {
+  const raw = String(name ?? "").trim();
+  return raw.replace(/^flash\d*(?=_(?:low|high)$|$)/, "flash");
+}
+
 // ── 용도별 effort (SSOT) ──
-// 한 세대(3.8 Flash)만 쓰고 역할에 따라 effort 를 나눈다. 키는 tfx 에이전트/역할 이름
+// Flash 가족 안에서 역할에 따라 effort 를 나눈다. 키는 tfx 에이전트/역할 이름
 // (agent-map.json 의 에이전트, tfx multi --assign 의 role). bash(tfx-route.sh)와
 // 실행 모드(execution-mode)가 이 표를 읽는다.
 //   High   : 판단이 결과를 좌우하는 역할 (검토, 설계, 디버깅, 분석)
 //   Medium : 생성/작성/실행 (기본값)
 //   Low    : 분류, 요약, 추출, 번역처럼 짧고 기계적인 작업
 const GEMINI_PROFILE_BY_PURPOSE = Object.freeze({
-  designer: "flash38_high",
-  reviewer: "flash38_high",
-  "code-reviewer": "flash38_high",
-  "security-reviewer": "flash38_high",
-  "quality-reviewer": "flash38_high",
-  critic: "flash38_high",
-  architect: "flash38_high",
-  verifier: "flash38_high",
-  analyst: "flash38_high",
-  debugger: "flash38_high",
-  planner: "flash38_high",
-  scientist: "flash38_high",
-  "test-engineer": "flash38_high",
-  writer: "flash38",
-  executor: "flash38",
-  worker: "flash38",
-  "document-specialist": "flash38",
-  researcher: "flash38",
-  antigravity: "flash38",
-  agy: "flash38",
-  gemini: "flash38",
-  summarizer: "flash38_low",
-  classifier: "flash38_low",
-  triage: "flash38_low",
-  translator: "flash38_low",
-  formatter: "flash38_low",
-  explore: "flash38_low",
+  designer: "flash_high",
+  reviewer: "flash_high",
+  "code-reviewer": "flash_high",
+  "security-reviewer": "flash_high",
+  "quality-reviewer": "flash_high",
+  critic: "flash_high",
+  architect: "flash_high",
+  verifier: "flash_high",
+  analyst: "flash_high",
+  debugger: "flash_high",
+  planner: "flash_high",
+  scientist: "flash_high",
+  "test-engineer": "flash_high",
+  writer: "flash",
+  executor: "flash",
+  worker: "flash",
+  "document-specialist": "flash",
+  researcher: "flash",
+  antigravity: "flash",
+  agy: "flash",
+  gemini: "flash",
+  summarizer: "flash_low",
+  classifier: "flash_low",
+  triage: "flash_low",
+  translator: "flash_low",
+  formatter: "flash_low",
+  explore: "flash_low",
 });
-const GEMINI_DEFAULT_PURPOSE_PROFILE = "flash38";
+const GEMINI_DEFAULT_PURPOSE_PROFILE = "flash";
 
 function resolveGeminiProfileForPurpose(name) {
   const key = String(name ?? "")
@@ -84,70 +76,66 @@ function resolveGeminiModel(profileOrModel, opts = {}) {
   const profilesPath =
     opts.profilesPath ||
     process.env.GEMINI_PROFILES_PATH ||
-    join(homedir(), ".gemini", "triflux-profiles.json");
+    join(modelFamilyPaths(opts).home, ".gemini", "triflux-profiles.json");
   let cfg = null;
   try {
     cfg = JSON.parse(readFileSync(profilesPath, "utf8"));
   } catch {
     cfg = null;
   }
-  const entry = cfg?.profiles?.[raw];
-  const fromFile = typeof entry === "string" ? entry : entry?.model;
-  if (typeof fromFile === "string" && fromFile.trim()) return fromFile.trim();
-  const fromDefault = DEFAULT_GEMINI_PROFILES.profiles[raw];
-  if (fromDefault) return fromDefault.model;
-  if (typeof cfg?.model === "string" && cfg.model.trim())
-    return cfg.model.trim();
-  return DEFAULT_GEMINI_PROFILES.model;
+  const name = normalizeGeminiProfileName(raw);
+  const modelValue = (entry) =>
+    typeof entry === "string"
+      ? entry
+      : typeof entry?.model === "string"
+        ? entry.model
+        : entry?.model?.name || entry?.name;
+  for (const bucket of [
+    cfg?.profiles,
+    cfg?.model?.profiles,
+    cfg?.modelProfiles,
+    cfg?.models,
+  ]) {
+    const entry = bucket?.[name] || bucket?.[raw];
+    const value = modelValue(entry);
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  if (name !== "default" && DEFAULT_GEMINI_PROFILES.profiles[name])
+    return DEFAULT_GEMINI_PROFILES.profiles[name].model;
+  const fallback =
+    cfg?.defaultModel ||
+    cfg?.default_profile ||
+    cfg?.defaultProfile ||
+    (typeof cfg?.model === "string" ? cfg.model : cfg?.model?.default);
+  if (typeof fallback === "string" && fallback.trim()) return fallback.trim();
+  const defaultProfile = normalizeGeminiProfileName(
+    (opts.env || process.env).TFX_GEMINI_DEFAULT_PROFILE,
+  );
+  return (
+    modelValue(cfg?.profiles?.[defaultProfile]) ||
+    DEFAULT_GEMINI_PROFILES.profiles[defaultProfile]?.model ||
+    DEFAULT_GEMINI_PROFILES.model
+  );
 }
 
-const DEFAULT_PROFILE_COUNT = Object.keys(
-  DEFAULT_GEMINI_PROFILES.profiles,
-).length;
-
-function ensureGeminiProfiles({
-  geminiDir = join(homedir(), ".gemini"),
-  profilesPath = join(geminiDir, "triflux-profiles.json"),
-} = {}) {
+function ensureGeminiProfiles(opts = {}) {
+  const geminiDir =
+    opts.geminiDir || join(modelFamilyPaths(opts).home, ".gemini");
+  const profilesPath =
+    opts.profilesPath ||
+    process.env.GEMINI_PROFILES_PATH ||
+    join(geminiDir, "triflux-profiles.json");
   try {
-    if (!existsSync(geminiDir)) mkdirSync(geminiDir, { recursive: true });
-
-    if (!existsSync(profilesPath)) {
-      writeFileSync(
-        profilesPath,
-        JSON.stringify(DEFAULT_GEMINI_PROFILES, null, 2) + "\n",
-        { encoding: "utf8", mode: 0o600 },
-      );
-      return {
-        ok: true,
-        created: true,
-        added: DEFAULT_PROFILE_COUNT,
-        count: DEFAULT_PROFILE_COUNT,
-        message: null,
-      };
-    }
-
     let cfg;
-    try {
-      cfg = JSON.parse(readFileSync(profilesPath, "utf8"));
-    } catch {
+    let created = !existsSync(profilesPath);
+    if (!created) {
       try {
-        copyFileSync(profilesPath, profilesPath + `.bak.${Date.now()}`);
-      } catch {}
-      writeFileSync(
-        profilesPath,
-        JSON.stringify(DEFAULT_GEMINI_PROFILES, null, 2) + "\n",
-        { encoding: "utf8", mode: 0o600 },
-      );
-      return {
-        ok: true,
-        created: true,
-        added: DEFAULT_PROFILE_COUNT,
-        count: DEFAULT_PROFILE_COUNT,
-        message: null,
-      };
+        cfg = JSON.parse(readFileSync(profilesPath, "utf8"));
+      } catch {
+        copyFileSync(profilesPath, `${profilesPath}.bak.${Date.now()}`);
+        created = true;
+      }
     }
-
     if (!cfg || typeof cfg !== "object" || Array.isArray(cfg)) cfg = {};
     if (
       !cfg.profiles ||
@@ -155,28 +143,25 @@ function ensureGeminiProfiles({
       Array.isArray(cfg.profiles)
     )
       cfg.profiles = {};
-
+    const { profiles } = resolveModelFamilies("agy", {
+      ...opts,
+      home: opts.home || dirname(geminiDir),
+    });
     let added = 0;
-    for (const [name, value] of Object.entries(
-      DEFAULT_GEMINI_PROFILES.profiles,
-    )) {
-      if (!cfg.profiles[name]) {
-        cfg.profiles[name] = value;
-        added++;
-      }
+    for (const [name, { model }] of Object.entries(profiles)) {
+      if (!cfg.profiles[name]) added++;
+      cfg.profiles[name] = { model };
     }
-    if (!cfg.model) cfg.model = DEFAULT_GEMINI_PROFILES.model;
-
-    if (added > 0) {
-      writeFileSync(profilesPath, JSON.stringify(cfg, null, 2) + "\n", {
-        encoding: "utf8",
-        mode: 0o600,
-      });
-    }
-
+    if (!cfg.model || /^Gemini \d+(?:\.\d+)* Flash \(/.test(cfg.model))
+      cfg.model = profiles.flash.model;
+    const changed = writeModelFile(
+      profilesPath,
+      `${JSON.stringify(cfg, null, 2)}\n`,
+    );
     return {
       ok: true,
-      created: false,
+      created,
+      changed,
       added,
       count: Object.keys(cfg.profiles).length,
       message: null,
@@ -185,6 +170,7 @@ function ensureGeminiProfiles({
     return {
       ok: false,
       created: false,
+      changed: false,
       added: 0,
       count: 0,
       message: error.message,

package/scripts/lib/model-family-resolver.mjs

@@ -0,0 +1,335 @@
+import { execFileSync } from "node:child_process";
+import {
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { resolveTrifluxHome } from "./machine-profile.mjs";
+
+export const CODEX_FAMILY_PROFILES = Object.freeze({
+  sol_high: { family: "sol", effort: "high", model: "gpt-6.1-sol" },
+  sol_med: { family: "sol", effort: "medium", model: "gpt-6.1-sol" },
+  astra_xhigh: { family: "astra", effort: "xhigh", model: "gpt-6-astra" },
+  astra_max: { family: "astra", effort: "max", model: "gpt-6-astra" },
+  astra_ultra: { family: "astra", effort: "ultra", model: "gpt-6-astra" },
+  luna_high: { family: "luna", effort: "high", model: "gpt-6-luna" },
+  luna_low: { family: "luna", effort: "low", model: "gpt-6-luna" },
+});
+export const FLASH_FAMILY_PROFILES = Object.freeze({
+  flash_low: {
+    family: "flash",
+    effort: "low",
+    model: "Gemini 3.8 Flash (Low)",
+  },
+  flash: {
+    family: "flash",
+    effort: "medium",
+    model: "Gemini 3.8 Flash (Medium)",
+  },
+  flash_high: {
+    family: "flash",
+    effort: "high",
+    model: "Gemini 3.8 Flash (High)",
+  },
+});
+const DAY_MS = 86_400_000;
+const CODEX_SLUG = /^gpt-(\d+(?:\.\d+)*)-(sol|astra|luna)$/;
+const FLASH_SLUG = /^gemini-(\d+(?:\.\d+)*)-flash-(low|medium|high)$/;
+
+function compareVersions(a, b) {
+  const left = a.split(".").map(Number);
+  const right = b.split(".").map(Number);
+  for (let i = 0; i < Math.max(left.length, right.length); i++) {
+    const difference = (left[i] || 0) - (right[i] || 0);
+    if (difference) return difference;
+  }
+  return 0;
+}
+
+export function selectCodexModel(models, family, effort) {
+  return (
+    (models || [])
+      .filter((item) => {
+        const match = CODEX_SLUG.exec(item?.slug);
+        return (
+          match?.[2] === family &&
+          item.visibility === "list" &&
+          Array.isArray(item.supported_reasoning_levels) &&
+          item.supported_reasoning_levels.some(
+            (level) => (level?.effort ?? level) === effort,
+          )
+        );
+      })
+      .sort((a, b) =>
+        compareVersions(CODEX_SLUG.exec(b.slug)[1], CODEX_SLUG.exec(a.slug)[1]),
+      )[0] || null
+  );
+}
+
+export function parseAgyModels(output) {
+  return String(output)
+    .split(/\r?\n/)
+    .flatMap((line) => {
+      const [slug, model] = line.trim().split("\t");
+      return FLASH_SLUG.test(slug) && model?.trim()
+        ? [{ slug, model: model.trim() }]
+        : [];
+    });
+}
+
+export function selectFlashModel(models, effort) {
+  return (
+    (models || [])
+      .filter(
+        (item) =>
+          FLASH_SLUG.exec(item?.slug)?.[2] === effort &&
+          typeof item.model === "string",
+      )
+      .sort((a, b) =>
+        compareVersions(FLASH_SLUG.exec(b.slug)[1], FLASH_SLUG.exec(a.slug)[1]),
+      )[0] || null
+  );
+}
+
+export function modelFamilyPaths(opts = {}) {
+  const env = opts.env || process.env;
+  const platform = opts.platform || process.platform;
+  const home = opts.home || resolveTrifluxHome({ env, platform });
+  const stateDir =
+    opts.stateDir ||
+    join(
+      platform === "win32"
+        ? env.APPDATA || join(home, "AppData", "Roaming")
+        : env.XDG_CONFIG_HOME || join(home, ".config"),
+      "triflux",
+    );
+  return {
+    home,
+    stateDir,
+    codexHome:
+      opts.codexHome ||
+      env.CODEX_HOME ||
+      env.TFX_CODEX_HOME ||
+      join(home, ".codex"),
+    pinsPath: join(stateDir, "models.json"),
+  };
+}
+
+function readJson(path) {
+  try {
+    const value = JSON.parse(readFileSync(path, "utf8"));
+    return value && typeof value === "object" && !Array.isArray(value)
+      ? value
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function signature(path) {
+  try {
+    const stat = statSync(path);
+    return `${path}:${stat.ino}:${stat.mtimeMs}:${stat.size}`;
+  } catch {
+    return `${path}:missing`;
+  }
+}
+
+export function writeModelFile(path, content) {
+  try {
+    if (readFileSync(path, "utf8") === content) return false;
+  } catch {}
+  mkdirSync(dirname(path), { recursive: true });
+  const temp = `${path}.${process.pid}.tmp`;
+  writeFileSync(temp, content, { encoding: "utf8", mode: 0o600 });
+  renameSync(temp, path);
+  return true;
+}
+
+function saveJson(path, value) {
+  try {
+    writeModelFile(path, `${JSON.stringify(value)}\n`);
+  } catch {
+    // 읽기 전용 상태 디렉터리여도 이번 실행의 해석 결과는 쓸 수 있다.
+  }
+}
+
+const codexCatalogs = new Map();
+export function readCodexModelCatalog(opts = {}) {
+  const path = join(modelFamilyPaths(opts).codexHome, "models_cache.json");
+  const key = signature(path);
+  let cached = codexCatalogs.get(path);
+  if (cached?.key !== key) {
+    const value = readJson(path);
+    cached = { key, catalog: Array.isArray(value?.models) ? value : null };
+    codexCatalogs.set(path, cached);
+  }
+  return cached.catalog;
+}
+
+export function resolveModelFamilies(provider, opts = {}) {
+  const paths = modelFamilyPaths(opts);
+  const definitions =
+    provider === "codex" ? CODEX_FAMILY_PROFILES : FLASH_FAMILY_PROFILES;
+  const recordPath = join(paths.stateDir, `${provider}-model-resolution.json`);
+  const previous = readJson(recordPath) || {};
+  const now = (opts.now || Date.now)();
+  const fetchedAt = new Date(now).toISOString();
+  const run =
+    opts.runCommand ||
+    ((command, args) =>
+      execFileSync(command, args, {
+        encoding: "utf8",
+        timeout: 10_000,
+        stdio: ["ignore", "pipe", "ignore"],
+        env: {
+          ...(opts.env || process.env),
+          HOME: paths.home,
+          CODEX_HOME: paths.codexHome,
+        },
+        maxBuffer: 4 * 1024 * 1024,
+      }));
+  let catalog = null;
+  let sourceSignature;
+  let checkedAt = previous.checked_at;
+  if (provider === "codex") {
+    const cachePath = join(paths.codexHome, "models_cache.json");
+    sourceSignature = signature(cachePath);
+    if (sourceSignature !== previous.sourceSignature)
+      catalog = readCodexModelCatalog(opts);
+    if (
+      sourceSignature.endsWith(":missing") &&
+      opts.allowCommand !== false &&
+      (!checkedAt || now - Date.parse(checkedAt) >= DAY_MS)
+    ) {
+      checkedAt = fetchedAt;
+      try {
+        const parsed = JSON.parse(
+          run(opts.command || "codex", ["debug", "models"]),
+        );
+        if (Array.isArray(parsed?.models))
+          catalog = { ...parsed, fetched_at: parsed.fetched_at || fetchedAt };
+      } catch {}
+    }
+  } else {
+    const cachePath = join(paths.stateDir, "agy-models.json");
+    let cached = readJson(cachePath) || {};
+    if (
+      opts.allowCommand !== false &&
+      (!cached.checked_at || now - Date.parse(cached.checked_at) >= DAY_MS)
+    ) {
+      const lock = `${cachePath}.lock`;
+      let acquired = false;
+      try {
+        if (opts.persist !== false) {
+          mkdirSync(paths.stateDir, { recursive: true });
+          // 프로세스가 끊긴 잠금만 회수한다. CLI 조회 제한은 10초다.
+          try {
+            if (now - statSync(lock).mtimeMs > 60_000)
+              rmSync(lock, { recursive: true, force: true });
+          } catch {}
+          mkdirSync(lock);
+          acquired = true;
+          cached = readJson(cachePath) || cached;
+        }
+        if (
+          !cached.checked_at ||
+          now - Date.parse(cached.checked_at) >= DAY_MS
+        ) {
+          cached.checked_at = fetchedAt;
+          try {
+            const models = parseAgyModels(
+              run(opts.command || "agy", ["models"]),
+            );
+            if (models.length)
+              cached = { models, fetched_at: fetchedAt, checked_at: fetchedAt };
+          } catch {}
+          if (opts.persist !== false) saveJson(cachePath, cached);
+        }
+      } catch {
+        // 다른 디스패치가 갱신 중이면 기존 결과로 실행한다.
+      } finally {
+        if (acquired) rmSync(lock, { recursive: true, force: true });
+      }
+    }
+    sourceSignature = signature(cachePath);
+    checkedAt = cached.checked_at;
+    if (Array.isArray(cached.models)) catalog = cached;
+  }
+  const profiles = {};
+  const selectedProfiles = {};
+  const pins = readJson(paths.pinsPath) || {};
+  for (const [name, definition] of Object.entries(definitions)) {
+    const saved = previous.profiles?.[name];
+    const last =
+      typeof saved?.model === "string" && saved.effort === definition.effort
+        ? saved
+        : null;
+    const candidate =
+      provider === "codex"
+        ? selectCodexModel(
+            catalog?.models,
+            definition.family,
+            definition.effort,
+          )
+        : selectFlashModel(catalog?.models, definition.effort);
+    profiles[name] =
+      candidate &&
+      (!last?.fetched_at ||
+        !catalog.fetched_at ||
+        Date.parse(catalog.fetched_at) >= Date.parse(last.fetched_at))
+        ? {
+            model: provider === "codex" ? candidate.slug : candidate.model,
+            effort: definition.effort,
+            fetched_at: catalog.fetched_at || fetchedAt,
+          }
+        : last || {
+            model: definition.model,
+            effort: definition.effort,
+            fetched_at: null,
+          };
+    selectedProfiles[name] = { ...profiles[name] };
+    const pin = pins[definition.family];
+    if (
+      typeof pin === "string" &&
+      provider === "codex" &&
+      CODEX_SLUG.exec(pin)?.[2] === definition.family
+    ) {
+      selectedProfiles[name] = {
+        model: pin,
+        effort: definition.effort,
+        source: paths.pinsPath,
+        fetched_at: null,
+      };
+    } else if (
+      typeof pin === "string" &&
+      provider === "agy" &&
+      /^gemini-\d+(?:\.\d+)*-flash$/.test(pin)
+    ) {
+      const slug = `${pin}-${definition.effort}`;
+      const version = pin.slice(7, -6);
+      const effort =
+        definition.effort[0].toUpperCase() + definition.effort.slice(1);
+      selectedProfiles[name] = {
+        model:
+          catalog?.models?.find((item) => item.slug === slug)?.model ||
+          `Gemini ${version} Flash (${effort})`,
+        effort: definition.effort,
+        source: paths.pinsPath,
+        fetched_at: null,
+      };
+    }
+  }
+  const record = {
+    sourceSignature,
+    checked_at: checkedAt || null,
+    profiles,
+    selectedProfiles,
+  };
+  if (opts.persist !== false) saveJson(recordPath, record);
+  return { profiles: selectedProfiles };
+}